pax_global_header00006660000000000000000000000064152510413030014504gustar00rootroot0000000000000052 comment=20307928dd3895964fa28284cd7723f657e31ff4 biopragmatics-curies-aa8bd37/000077500000000000000000000000001525104130300163135ustar00rootroot00000000000000biopragmatics-curies-aa8bd37/.cruft.json000066400000000000000000000016331525104130300204120ustar00rootroot00000000000000{ "template": "https://github.com/cthoyt/cookiecutter-snekpack", "commit": "e3a8928186124d29d96565e16894fae924b067f9", "checkout": null, "context": { "cookiecutter": { "package_name": "curies", "package_name_stylized": "CURIEs", "short_description": "Idiomatic conversion between URIs and compact URIs (CURIEs)", "author_name": "Charles Tapley Hoyt", "author_github": "cthoyt", "author_email": "cthoyt@gmail.com", "github_organization_name": "biopragmatics", "github_repository_name": "curies", "command_line_interface": true, "gitlab": false, "runner": "tox", "__runner": "tox -e", "__runner_uv": "--with tox-uv tox -e", "__runner_pip": "tox tox-uv", "__runner_tests": "py", "__gh_slug": "biopragmatics/curies", "_template": "https://github.com/cthoyt/cookiecutter-snekpack" } }, "directory": null } biopragmatics-curies-aa8bd37/.github/000077500000000000000000000000001525104130300176535ustar00rootroot00000000000000biopragmatics-curies-aa8bd37/.github/CODE_OF_CONDUCT.md000066400000000000000000000125511525104130300224560ustar00rootroot00000000000000# Contributor Covenant Code of Conduct ## Our Pledge We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, caste, color, religion, or sexual identity and orientation. We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community. ## Our Standards Examples of behavior that contributes to a positive environment for our community include: - Demonstrating empathy and kindness toward other people - Being respectful of differing opinions, viewpoints, and experiences - Giving and gracefully accepting constructive feedback - Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience - Focusing on what is best not just for us as individuals, but for the overall community Examples of unacceptable behavior include: - The use of sexualized language or imagery, and sexual attention or advances of any kind - Trolling, insulting or derogatory comments, and personal or political attacks - Public or private harassment - Publishing others' private information, such as a physical or email address, without their explicit permission - Other conduct which could reasonably be considered inappropriate in a professional setting ## Enforcement Responsibilities Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful. Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate. ## Scope This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. ## Enforcement Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at cthoyt@gmail.com. All complaints will be reviewed and investigated promptly and fairly. All community leaders are obligated to respect the privacy and security of the reporter of any incident. ## Enforcement Guidelines Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct: ### 1. Correction **Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community. **Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested. ### 2. Warning **Community Impact**: A violation through a single incident or series of actions. **Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban. ### 3. Temporary Ban **Community Impact**: A serious violation of community standards, including sustained inappropriate behavior. **Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban. ### 4. Permanent Ban **Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals. **Consequence**: A permanent ban from any sort of public interaction within the community. ## Attribution This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.1, available at [https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1]. Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder][Mozilla CoC]. For answers to common questions about this code of conduct, see the FAQ at [https://www.contributor-covenant.org/faq][FAQ]. Translations are available at [https://www.contributor-covenant.org/translations][translations]. [homepage]: https://www.contributor-covenant.org [v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html [Mozilla CoC]: https://github.com/mozilla/diversity [FAQ]: https://www.contributor-covenant.org/faq [translations]: https://www.contributor-covenant.org/translations biopragmatics-curies-aa8bd37/.github/CONTRIBUTING.md000066400000000000000000000120671525104130300221120ustar00rootroot00000000000000# Contributing Contributions to this repository are welcomed and encouraged. ## Code Contribution This project uses the [GitHub Flow](https://guides.github.com/introduction/flow) model for code contributions. Follow these steps: 1. [Create a fork](https://help.github.com/articles/fork-a-repo) of the upstream repository at [`biopragmatics/curies`](https://github.com/biopragmatics/curies) on your GitHub account (or in one of your organizations) 2. [Clone your fork](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository) with `git clone https://github.com//curies.git` 3. Make and commit changes to your fork with `git commit` 4. Push changes to your fork with `git push` 5. Repeat steps 3 and 4 as needed 6. Submit a pull request back to the upstream repository ### Merge Model This repository uses [squash merges](https://docs.github.com/en/github/collaborating-with-pull-requests/incorporating-changes-from-a-pull-request/about-pull-request-merges#squash-and-merge-your-pull-request-commits) to group all related commits in a given pull request into a single commit upon acceptance and merge into the main branch. This has several benefits: 1. Keeps the commit history on the main branch focused on high-level narrative 2. Enables people to make lots of small commits without worrying about muddying up the commit history 3. Commits correspond 1-to-1 with pull requests ### Code Style This project uses `tox` for running code quality checks. Start by installing it with `pip install tox tox-uv`. This project encourages the use of optional static typing. It uses [`mypy`](http://mypy-lang.org/) as a type checker. You can check if your code passes `mypy` with `tox -e mypy`. This project uses [`ruff`](https://docs.astral.sh/ruff/) to automatically enforce a consistent code style. You can apply `ruff format` and other pre-configured formatters with `tox -e format`. This project uses [`ruff`](https://docs.astral.sh/ruff/) and several plugins for additional checks of documentation style, security issues, good variable nomenclature, and more (see `pyproject.toml` for a list of Ruff plugins). You can check if your code passes `ruff check` with `tox -e lint`. Each of these checks are run on each commit using GitHub Actions as a continuous integration service. Passing all of them is required for accepting a contribution. If you're unsure how to address the feedback from one of these tools, please say so either in the description of your pull request or in a comment, and we will help you. ### Logging Python's builtin `print()` should not be used (except when writing to files), it's checked by the [`flake8-print` (T20)](https://docs.astral.sh/ruff/rules/#flake8-print-t20) plugin to `ruff`. If you're in a command line setting or `main()` function for a module, you can use `click.echo()`. Otherwise, you can use the builtin `logging` module by adding `logger = logging.getLogger(__name__)` below the imports at the top of your file. ### Documentation All public functions (i.e., not starting with an underscore `_`) must be documented using the [sphinx documentation format](https://sphinx-rtd-tutorial.readthedocs.io/en/latest/docstrings.html#the-sphinx-docstring-format). The [`darglint2`](https://github.com/akaihola/darglint2) tool reports on functions that are not fully documented. This project uses [`sphinx`](https://www.sphinx-doc.org) to automatically build documentation into a narrative structure. You can check that the documentation builds properly in an isolated environment with `tox -e docs-test` and actually build it locally with `tox -e docs`. ### Testing Functions in this repository should be unit tested. These can either be written using the `unittest` framework in the `tests/` directory or as embedded doctests. You can check that the unit tests pass with `tox -e py` and that the doctests pass with `tox -e doctests`. These tests are required to pass for accepting a contribution. ### Syncing your fork If other code is updated before your contribution gets merged, you might need to resolve conflicts against the main branch. After cloning, you should add the upstream repository with ```shell $ git remote add biopragmatics https://github.com/biopragmatics/curies.git ``` Then, you can merge upstream code into your branch. You can also use the GitHub UI to do this by following [this tutorial](https://docs.github.com/en/github/collaborating-with-pull-requests/working-with-forks/syncing-a-fork). ### Python Version Compatibility This project aims to support all versions of Python that have not passed their end-of-life dates. After end-of-life, the version will be removed from the Trove qualifiers in the `pyproject.toml` and from the GitHub Actions testing configuration. See https://endoflife.date/python for a timeline of Python release and end-of-life dates. ## Acknowledgements These code contribution guidelines are derived from the [cthoyt/cookiecutter-snekpack](https://github.com/cthoyt/cookiecutter-snekpack) Python package template. They're free to reuse and modify as long as they're properly acknowledged. biopragmatics-curies-aa8bd37/.github/FUNDING.yml000066400000000000000000000002701525104130300214670ustar00rootroot00000000000000# https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/displaying-a-sponsor-button-in-your-repository github: - cthoyt biopragmatics-curies-aa8bd37/.github/PULL_REQUEST_TEMPLATE.md000066400000000000000000000011241525104130300234520ustar00rootroot00000000000000 ## Summary biopragmatics-curies-aa8bd37/.github/codecov.yml000066400000000000000000000001631525104130300220200ustar00rootroot00000000000000# see https://docs.codecov.com/v4.6/docs/codecov-yaml ignore: - "src/curies/__main__.py" - "src/curies/cli.py" biopragmatics-curies-aa8bd37/.github/workflows/000077500000000000000000000000001525104130300217105ustar00rootroot00000000000000biopragmatics-curies-aa8bd37/.github/workflows/cruft.yml000066400000000000000000000045151525104130300235630ustar00rootroot00000000000000# from https://cruft.github.io/cruft/#automating-updates-with-github-actions name: Update repository with Cruft permissions: {} on: workflow_dispatch: schedule: - cron: "0 2 * * 1" # Every Monday at 2am jobs: update: permissions: contents: write pull-requests: write runs-on: ubuntu-latest strategy: fail-fast: true matrix: include: - add-paths: . body: Use this to merge the changes to this repository. branch: cruft/update commit-message: "chore: accept new Cruft update" title: New updates detected with Cruft - add-paths: .cruft.json body: Use this to reject the changes in this repository. branch: cruft/reject commit-message: "chore: reject new Cruft update" title: Reject new updates detected with Cruft steps: - uses: actions/checkout@v3 - uses: actions/setup-python@v4 with: python-version: "3.11" - name: Install Cruft run: pip3 install cruft - name: Check if update is available continue-on-error: false id: check run: | CHANGES=0 if [ -f .cruft.json ]; then if ! cruft check; then CHANGES=1 fi else echo "No .cruft.json file" fi echo "has_changes=$CHANGES" >> "$GITHUB_OUTPUT" - name: Run update if available if: steps.check.outputs.has_changes == '1' run: | git config --global user.email "you@example.com" git config --global user.name "GitHub" cruft update --skip-apply-ask --refresh-private-variables git restore --staged . - name: Create pull request if: steps.check.outputs.has_changes == '1' uses: peter-evans/create-pull-request@v4 with: token: ${{ secrets.GITHUB_TOKEN }} add-paths: ${{ matrix.add-paths }} commit-message: ${{ matrix.commit-message }} branch: ${{ matrix.branch }} delete-branch: true branch-suffix: timestamp title: ${{ matrix.title }} body: | This is an autogenerated PR. ${{ matrix.body }} [Cruft](https://cruft.github.io/cruft/) has detected updates from the Cookiecutter repository. biopragmatics-curies-aa8bd37/.github/workflows/tests.yml000066400000000000000000000067561525104130300236130ustar00rootroot00000000000000# This file configures the continuous integration (CI) system on GitHub. # Introductory materials can be found here: https://docs.github.com/en/actions/learn-github-actions/understanding-github-actions. # Documentation for editing this file can be found here: https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions name: Tests # by default, give the GITHUB_TOKEN no permissions # See https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/controlling-permissions-for-github_token permissions: {} on: push: branches: [main] pull_request: branches: [main] jobs: lint: name: Code Quality permissions: # give only read-only access to the contents of the repository # this is the only permission this job requires, so keep it to the least privilege # i.e., not to issues, discussions, actions, etc. contents: read runs-on: ubuntu-latest strategy: matrix: python-version: ["3.14", "3.11"] tox-command: ["lint", "mypy"] steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 - name: "Install uv" uses: astral-sh/setup-uv@5a095e7a2014a4212f075830d4f7277575a9d098 # v7.3.1 with: enable-cache: true cache-dependency-glob: "pyproject.toml" - name: "Run command" run: | uvx -p ${{ matrix.python-version }} --with tox-uv tox -e ${{ matrix.tox-command }} docs: name: Documentation permissions: contents: read runs-on: ubuntu-latest strategy: matrix: # We only test documentation on the latest version # sphinx 8.0 / sphinx-rtd-theme 3.0 discontinued Python 3.9 support # a year early, which prompted re-thinking about this. python-version: ["3.14"] steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 - name: "Install uv" uses: astral-sh/setup-uv@5a095e7a2014a4212f075830d4f7277575a9d098 # v7.3.1 with: enable-cache: true cache-dependency-glob: "pyproject.toml" - name: Install dependencies run: | sudo apt-get install graphviz - name: Lint documentation run: uvx -p ${{ matrix.python-version }} --with tox-uv tox -e docs-lint - name: Check docstring coverage run: uvx -p ${{ matrix.python-version }} --with tox-uv tox -e docstr-coverage - name: Check documentation build with Sphinx run: uvx -p ${{ matrix.python-version }} --with tox-uv tox -e docs-test tests: name: Tests permissions: contents: read runs-on: ${{ matrix.os }} strategy: matrix: os: [ubuntu-latest] python-version: ["3.14", "3.11"] pandas: ["pandas2", "pandas3"] exclude: - python-version: "3.11" pandas: "pandas3" steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 - name: "Install uv" uses: astral-sh/setup-uv@5a095e7a2014a4212f075830d4f7277575a9d098 # v7.3.1 with: enable-cache: true cache-dependency-glob: "pyproject.toml" - name: Test with pytest and generate coverage file run: uvx -p ${{ matrix.python-version }} --with tox-uv tox -e py-${{ matrix.pandas }} - name: Upload coverage report to codecov uses: codecov/codecov-action@671740ac38dd9b0130fbe1cec585b89eea48d3de # v5.5.2 if: success() with: file: coverage.xml biopragmatics-curies-aa8bd37/.gitignore000066400000000000000000000400301525104130300203000ustar00rootroot00000000000000# Created by https://www.toptal.com/developers/gitignore/api/macos,linux,windows,python,jupyternotebooks,jetbrains,pycharm,vim,emacs,visualstudiocode,visualstudio # Edit at https://www.toptal.com/developers/gitignore?templates=macos,linux,windows,python,jupyternotebooks,jetbrains,pycharm,vim,emacs,visualstudiocode,visualstudio ### Emacs ### # -*- mode: gitignore; -*- *~ \#*\# /.emacs.desktop /.emacs.desktop.lock *.elc auto-save-list tramp .\#* # Org-mode .org-id-locations *_archive # flymake-mode *_flymake.* # eshell files /eshell/history /eshell/lastdir # elpa packages /elpa/ # reftex files *.rel # AUCTeX auto folder /auto/ # cask packages .cask/ dist/ # Flycheck flycheck_*.el # server auth directory /server/ # projectiles files .projectile # directory configuration .dir-locals.el # network security /network-security.data ### JetBrains ### # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 # User-specific stuff .idea/**/workspace.xml .idea/**/tasks.xml .idea/**/usage.statistics.xml .idea/**/dictionaries .idea/**/shelf # AWS User-specific .idea/**/aws.xml # Generated files .idea/**/contentModel.xml # Sensitive or high-churn files .idea/**/dataSources/ .idea/**/dataSources.ids .idea/**/dataSources.local.xml .idea/**/sqlDataSources.xml .idea/**/dynamic.xml .idea/**/uiDesigner.xml .idea/**/dbnavigator.xml # Gradle .idea/**/gradle.xml .idea/**/libraries # Gradle and Maven with auto-import # When using Gradle or Maven with auto-import, you should exclude module files, # since they will be recreated, and may cause churn. Uncomment if using # auto-import. # .idea/artifacts # .idea/compiler.xml # .idea/jarRepositories.xml # .idea/modules.xml # .idea/*.iml # .idea/modules # *.iml # *.ipr # CMake cmake-build-*/ # Mongo Explorer plugin .idea/**/mongoSettings.xml # File-based project format *.iws # IntelliJ out/ # mpeltonen/sbt-idea plugin .idea_modules/ # JIRA plugin atlassian-ide-plugin.xml # Cursive Clojure plugin .idea/replstate.xml # SonarLint plugin .idea/sonarlint/ # Crashlytics plugin (for Android Studio and IntelliJ) com_crashlytics_export_strings.xml crashlytics.properties crashlytics-build.properties fabric.properties # Editor-based Rest Client .idea/httpRequests # Android studio 3.1+ serialized cache file .idea/caches/build_file_checksums.ser ### JetBrains Patch ### # Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721 # *.iml # modules.xml # .idea/misc.xml # *.ipr # Sonarlint plugin # https://plugins.jetbrains.com/plugin/7973-sonarlint .idea/**/sonarlint/ # SonarQube Plugin # https://plugins.jetbrains.com/plugin/7238-sonarqube-community-plugin .idea/**/sonarIssues.xml # Markdown Navigator plugin # https://plugins.jetbrains.com/plugin/7896-markdown-navigator-enhanced .idea/**/markdown-navigator.xml .idea/**/markdown-navigator-enh.xml .idea/**/markdown-navigator/ # Cache file creation bug # See https://youtrack.jetbrains.com/issue/JBR-2257 .idea/$CACHE_FILE$ # CodeStream plugin # https://plugins.jetbrains.com/plugin/12206-codestream .idea/codestream.xml ### JupyterNotebooks ### # gitignore template for Jupyter Notebooks # website: http://jupyter.org/ .ipynb_checkpoints */.ipynb_checkpoints/* # IPython profile_default/ ipython_config.py # Remove previous ipynb_checkpoints # git rm -r .ipynb_checkpoints/ ### Linux ### # temporary files which can be created if a process still has a handle open of a deleted file .fuse_hidden* # KDE directory preferences .directory # Linux trash folder which might appear on any partition or disk .Trash-* # .nfs files are created when an open file is removed but is still being accessed .nfs* ### macOS ### # General .DS_Store .AppleDouble .LSOverride # Icon must end with two \r Icon # Thumbnails ._* # Files that might appear in the root of a volume .DocumentRevisions-V100 .fseventsd .Spotlight-V100 .TemporaryItems .Trashes .VolumeIcon.icns .com.apple.timemachine.donotpresent # Directories potentially created on remote AFP share .AppleDB .AppleDesktop Network Trash Folder Temporary Items .apdisk ### PyCharm ### # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 # User-specific stuff # AWS User-specific # Generated files # Sensitive or high-churn files # Gradle # Gradle and Maven with auto-import # When using Gradle or Maven with auto-import, you should exclude module files, # since they will be recreated, and may cause churn. Uncomment if using # auto-import. # .idea/artifacts # .idea/compiler.xml # .idea/jarRepositories.xml # .idea/modules.xml # .idea/*.iml # .idea/modules # *.iml # *.ipr # CMake # Mongo Explorer plugin # File-based project format # IntelliJ # mpeltonen/sbt-idea plugin # JIRA plugin # Cursive Clojure plugin # SonarLint plugin # Crashlytics plugin (for Android Studio and IntelliJ) # Editor-based Rest Client # Android studio 3.1+ serialized cache file ### PyCharm Patch ### # Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721 # *.iml # modules.xml # .idea/misc.xml # *.ipr # Sonarlint plugin # https://plugins.jetbrains.com/plugin/7973-sonarlint # SonarQube Plugin # https://plugins.jetbrains.com/plugin/7238-sonarqube-community-plugin # Markdown Navigator plugin # https://plugins.jetbrains.com/plugin/7896-markdown-navigator-enhanced # Cache file creation bug # See https://youtrack.jetbrains.com/issue/JBR-2257 # CodeStream plugin # https://plugins.jetbrains.com/plugin/12206-codestream ### Python ### # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions *.so # Distribution / packaging .Python build/ develop-eggs/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ wheels/ share/python-wheels/ *.egg-info/ .installed.cfg *.egg MANIFEST # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .nox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *.cover *.py,cover .hypothesis/ .pytest_cache/ cover/ # Translations *.mo *.pot # Django stuff: *.log local_settings.py db.sqlite3 db.sqlite3-journal # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs/_build/ docs/build docs/source/api # PyBuilder .pybuilder/ target/ # Jupyter Notebook # IPython # pyenv # For a library or package, you might want to ignore these files since the code is # intended to run in multiple environments; otherwise, check them in: # .python-version # pipenv # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. # However, in case of collaboration, if having platform-specific dependencies or dependencies # having no cross-platform support, pipenv may install dependencies that don't work, or not # install all needed dependencies. #Pipfile.lock # poetry # Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. # This is especially recommended for binary packages to ensure reproducibility, and is more # commonly ignored for libraries. # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control #poetry.lock # PEP 582; used by e.g. github.com/David-OConnor/pyflow __pypackages__/ # Celery stuff celerybeat-schedule celerybeat.pid # SageMath parsed files *.sage.py # Environments .env .venv env/ venv/ ENV/ env.bak/ venv.bak/ # Spyder project settings .spyderproject .spyproject # Rope project settings .ropeproject # mkdocs documentation /site # mypy .mypy_cache/ .dmypy.json dmypy.json # Pyre type checker .pyre/ # pytype static type analyzer .pytype/ # Cython debug symbols cython_debug/ # PyCharm # JetBrains specific template is maintainted in a separate JetBrains.gitignore that can # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore # and can be added to the global gitignore or merged into this file. For a more nuclear # option (not recommended) you can uncomment the following to ignore the entire idea folder. #.idea/ ### Vim ### # Swap [._]*.s[a-v][a-z] !*.svg # comment out if you don't need vector files [._]*.sw[a-p] [._]s[a-rt-v][a-z] [._]ss[a-gi-z] [._]sw[a-p] # Session Session.vim Sessionx.vim # Temporary .netrwhist # Auto-generated tag files tags # Persistent undo [._]*.un~ ### VisualStudioCode ### .vscode/* !.vscode/settings.json !.vscode/tasks.json !.vscode/launch.json !.vscode/extensions.json !.vscode/*.code-snippets # Local History for Visual Studio Code .history/ # Built Visual Studio Code Extensions *.vsix ### VisualStudioCode Patch ### # Ignore all local history of files .history .ionide # Support for Project snippet scope ### Windows ### # Windows thumbnail cache files Thumbs.db Thumbs.db:encryptable ehthumbs.db ehthumbs_vista.db # Dump file *.stackdump # Folder config file [Dd]esktop.ini # Recycle Bin used on file shares $RECYCLE.BIN/ # Windows Installer files *.cab *.msi *.msix *.msm *.msp # Windows shortcuts *.lnk ### VisualStudio ### ## Ignore Visual Studio temporary files, build results, and ## files generated by popular Visual Studio add-ons. ## ## Get latest from https://github.com/github/gitignore/blob/main/VisualStudio.gitignore # User-specific files *.rsuser *.suo *.user *.userosscache *.sln.docstates # User-specific files (MonoDevelop/Xamarin Studio) *.userprefs # Mono auto generated files mono_crash.* # Build results [Dd]ebug/ [Dd]ebugPublic/ [Rr]elease/ [Rr]eleases/ x64/ x86/ [Ww][Ii][Nn]32/ [Aa][Rr][Mm]/ [Aa][Rr][Mm]64/ bld/ [Bb]in/ [Oo]bj/ [Ll]og/ [Ll]ogs/ # Visual Studio 2015/2017 cache/options directory .vs/ # Uncomment if you have tasks that create the project's static files in wwwroot #wwwroot/ # Visual Studio 2017 auto generated files Generated\ Files/ # MSTest test Results [Tt]est[Rr]esult*/ [Bb]uild[Ll]og.* # NUnit *.VisualState.xml TestResult.xml nunit-*.xml # Build Results of an ATL Project [Dd]ebugPS/ [Rr]eleasePS/ dlldata.c # Benchmark Results BenchmarkDotNet.Artifacts/ # .NET Core project.lock.json project.fragment.lock.json artifacts/ # ASP.NET Scaffolding ScaffoldingReadMe.txt # StyleCop StyleCopReport.xml # Files built by Visual Studio *_i.c *_p.c *_h.h *.ilk *.meta *.obj *.iobj *.pch *.pdb *.ipdb *.pgc *.pgd *.rsp *.sbr *.tlb *.tli *.tlh *.tmp *.tmp_proj *_wpftmp.csproj *.tlog *.vspscc *.vssscc .builds *.pidb *.svclog *.scc # Chutzpah Test files _Chutzpah* # Visual C++ cache files ipch/ *.aps *.ncb *.opendb *.opensdf *.sdf *.cachefile *.VC.db *.VC.VC.opendb # Visual Studio profiler *.psess *.vsp *.vspx *.sap # Visual Studio Trace Files *.e2e # TFS 2012 Local Workspace $tf/ # Guidance Automation Toolkit *.gpState # ReSharper is a .NET coding add-in _ReSharper*/ *.[Rr]e[Ss]harper *.DotSettings.user # TeamCity is a build add-in _TeamCity* # DotCover is a Code Coverage Tool *.dotCover # AxoCover is a Code Coverage Tool .axoCover/* !.axoCover/settings.json # Coverlet is a free, cross platform Code Coverage Tool coverage*.json coverage*.xml coverage*.info # Visual Studio code coverage results *.coverage *.coveragexml # NCrunch _NCrunch_* .*crunch*.local.xml nCrunchTemp_* # MightyMoose *.mm.* AutoTest.Net/ # Web workbench (sass) .sass-cache/ # Installshield output folder [Ee]xpress/ # DocProject is a documentation generator add-in DocProject/buildhelp/ DocProject/Help/*.HxT DocProject/Help/*.HxC DocProject/Help/*.hhc DocProject/Help/*.hhk DocProject/Help/*.hhp DocProject/Help/Html2 DocProject/Help/html # Click-Once directory publish/ # Publish Web Output *.[Pp]ublish.xml *.azurePubxml # Note: Comment the next line if you want to checkin your web deploy settings, # but database connection strings (with potential passwords) will be unencrypted *.pubxml *.publishproj # Microsoft Azure Web App publish settings. Comment the next line if you want to # checkin your Azure Web App publish settings, but sensitive information contained # in these scripts will be unencrypted PublishScripts/ # NuGet Packages *.nupkg # NuGet Symbol Packages *.snupkg # The packages folder can be ignored because of Package Restore **/[Pp]ackages/* # except build/, which is used as an MSBuild target. !**/[Pp]ackages/build/ # Uncomment if necessary however generally it will be regenerated when needed #!**/[Pp]ackages/repositories.config # NuGet v3's project.json files produces more ignorable files *.nuget.props *.nuget.targets # Microsoft Azure Build Output csx/ *.build.csdef # Microsoft Azure Emulator ecf/ rcf/ # Windows Store app package directories and files AppPackages/ BundleArtifacts/ Package.StoreAssociation.xml _pkginfo.txt *.appx *.appxbundle *.appxupload # Visual Studio cache files # files ending in .cache can be ignored *.[Cc]ache # but keep track of directories ending in .cache !?*.[Cc]ache/ # Others ClientBin/ ~$* *.dbmdl *.dbproj.schemaview *.jfm *.pfx *.publishsettings orleans.codegen.cs # Including strong name files can present a security risk # (https://github.com/github/gitignore/pull/2483#issue-259490424) #*.snk # Since there are multiple workflows, uncomment next line to ignore bower_components # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) #bower_components/ # RIA/Silverlight projects Generated_Code/ # Backup & report files from converting an old project file # to a newer Visual Studio version. Backup files are not needed, # because we have git ;-) _UpgradeReport_Files/ Backup*/ UpgradeLog*.XML UpgradeLog*.htm ServiceFabricBackup/ *.rptproj.bak # SQL Server files *.mdf *.ldf *.ndf # Business Intelligence projects *.rdl.data *.bim.layout *.bim_*.settings *.rptproj.rsuser *- [Bb]ackup.rdl *- [Bb]ackup ([0-9]).rdl *- [Bb]ackup ([0-9][0-9]).rdl # Microsoft Fakes FakesAssemblies/ # GhostDoc plugin setting file *.GhostDoc.xml # Node.js Tools for Visual Studio .ntvs_analysis.dat node_modules/ # Visual Studio 6 build log *.plg # Visual Studio 6 workspace options file *.opt # Visual Studio 6 auto-generated workspace file (contains which files were open etc.) *.vbw # Visual Studio 6 auto-generated project file (contains which files were open etc.) *.vbp # Visual Studio 6 workspace and project file (working project files containing files to include in project) *.dsw *.dsp # Visual Studio 6 technical files # Visual Studio LightSwitch build output **/*.HTMLClient/GeneratedArtifacts **/*.DesktopClient/GeneratedArtifacts **/*.DesktopClient/ModelManifest.xml **/*.Server/GeneratedArtifacts **/*.Server/ModelManifest.xml _Pvt_Extensions # Paket dependency manager .paket/paket.exe paket-files/ # FAKE - F# Make .fake/ # CodeRush personal settings .cr/personal # Python Tools for Visual Studio (PTVS) *.pyc # Cake - Uncomment if you are using it # tools/** # !tools/packages.config # Tabs Studio *.tss # Telerik's JustMock configuration file *.jmconfig # BizTalk build output *.btp.cs *.btm.cs *.odx.cs *.xsd.cs # OpenCover UI analysis results OpenCover/ # Azure Stream Analytics local run output ASALocalRun/ # MSBuild Binary and Structured Log *.binlog # NVidia Nsight GPU debugger configuration file *.nvuser # MFractors (Xamarin productivity tool) working folder .mfractor/ # Local History for Visual Studio .localhistory/ # Visual Studio History (VSHistory) files .vshistory/ # BeatPulse healthcheck temp database healthchecksdb # Backup folder for Package Reference Convert tool in Visual Studio 2017 MigrationBackup/ # Ionide (cross platform F# VS Code tools) working folder .ionide/ # Fody - auto-generated XML schema FodyWeavers.xsd # VS Code files for those working on multiple tools *.code-workspace # Local History for Visual Studio Code # Windows Installer files from build outputs # JetBrains Rider *.sln.iml ### VisualStudio Patch ### # Additional files built by Visual Studio # End of https://www.toptal.com/developers/gitignore/api/macos,linux,windows,python,jupyternotebooks,jetbrains,pycharm,vim,emacs,visualstudiocode,visualstudio scratch/ biopragmatics-curies-aa8bd37/.readthedocs.yml000066400000000000000000000015701525104130300214040ustar00rootroot00000000000000# .readthedocs.yaml # Read the Docs configuration file # See https://docs.readthedocs.io/en/stable/config-file/v2.html for details version: 2 # Set the version of Python and other tools you might need build: os: ubuntu-22.04 apt_packages: - graphviz tools: python: "3.12" # adapted from uv recipe at https://docs.readthedocs.io/en/stable/build-customization.html#install-dependencies-with-uv # and comment at https://github.com/readthedocs/readthedocs.org/issues/11289#issuecomment-2103832834 commands: - asdf plugin add uv - asdf install uv latest - asdf global uv latest - uv venv $READTHEDOCS_VIRTUALENV_PATH - VIRTUAL_ENV=$READTHEDOCS_VIRTUALENV_PATH uv pip install --group docs .[pandas,flask,fastapi,rdflib,sqlmodels,sqlalchemy] - python -m sphinx -T -b html -d docs/_build/doctrees -D language=en docs/source $READTHEDOCS_OUTPUT/html biopragmatics-curies-aa8bd37/LICENSE000066400000000000000000000020641525104130300173220ustar00rootroot00000000000000MIT License Copyright (c) 2026 Charles Tapley Hoyt Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. biopragmatics-curies-aa8bd37/README.md000066400000000000000000000271111525104130300175740ustar00rootroot00000000000000

CURIEs

Tests PyPI PyPI - Python Version PyPI - License Documentation Status Codecov status Cookiecutter template from @cthoyt Ruff Contributor Covenant DOI

Idiomatic conversion between URIs and compact URIs (CURIEs). ```python import curies converter = curies.load_prefix_map({ "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", # ... and so on }) >>> converter.compress("http://purl.obolibrary.org/obo/CHEBI_1") 'CHEBI:1' >>> converter.expand("CHEBI:1") 'http://purl.obolibrary.org/obo/CHEBI_1' ``` Full documentation is available at [curies.readthedocs.io](https://curies.readthedocs.io). ### CLI Usage This package comes with a built-in CLI for running a resolver web application or a IRI mapper web application: ```shell # Run a resolver python -m curies resolver --host 0.0.0.0 --port 8764 bioregistry # Run a mapper python -m curies mapper --host 0.0.0.0 --port 8764 bioregistry ``` The positional argument can be one of the following: 1. A pre-defined prefix map to get from the web (bioregistry, go, obo, monarch, prefixcommons) 2. A local file path or URL to a prefix map, extended prefix map, or one of several formats. Requires specifying a `--format`. The framework can be swapped to use Flask (default) or FastAPI with `--framework`. The server can be swapped to use Werkzeug (default) or Uvicorn with `--server`. These functionalities are also available programmatically, see the docs for more information. ## 🧑‍🤝‍🧑 Related Other packages that convert between CURIEs and URIs: - https://github.com/prefixcommons/prefixcommons-py (Python) - https://github.com/prefixcommons/curie-util (Java) - https://github.com/geneontology/curie-util-py (Python) - https://github.com/geneontology/curie-util-es5 (Node.js) - https://github.com/endoli/curie.rs (Rust) - https://github.com/cthoyt/curies4j (Java) - https://github.com/biopragmatics/curies.rs (Rust, Node.js, Python) ## 🚀 Installation The most recent release can be installed from [PyPI](https://pypi.org/project/curies/) with: ```console python3 -m pip install curies ``` As of v0.8, this package only supports Pydantic v2. v0.6.x and v0.7.x had cross-version support for Pydantic v1 and v2. v0.5.x and before only supported Pydantic v1. See the [Pydantic migration guide](https://docs.pydantic.dev/2.0/migration/) for updating your code. ## 👐 Contributing Contributions, whether filing an issue, making a pull request, or forking, are appreciated. See [CONTRIBUTING.md](https://github.com/biopragmatics/curies/blob/master/.github/CONTRIBUTING.md) for more information on getting involved. ## Users See [who's using `curies`](https://github.com/search?q=%22import%20curies%22%20OR%20%22from%20curies%20import%22%20-user%3Acthoyt%20-user%3Abiopragmatics%20-is%3Afork%20language%3APython&type=code&l=Python). ## 👋 Attribution ### 🙏 Acknowledgements This package heavily builds on the [trie](https://en.wikipedia.org/wiki/Trie) data structure implemented in [`pytrie`](https://github.com/gsakkis/pytrie). ### ⚖️ License The code in this package is licensed under the MIT License. ### 🍪 Cookiecutter This package was created with [@audreyfeldroy](https://github.com/audreyfeldroy)'s [cookiecutter](https://github.com/cookiecutter/cookiecutter) package using [@cthoyt](https://github.com/cthoyt)'s [cookiecutter-snekpack](https://github.com/cthoyt/cookiecutter-snekpack) template. ## 🛠️ For Developers
See developer instructions The final section of the README is for if you want to get involved by making a code contribution. ### Development Installation To install in development mode, use the following: ```console $ git clone git+https://github.com/biopragmatics/curies.git $ cd curies $ uv --preview pip install -e . ``` Alternatively, install using legacy pip with `UV_PREVIEW` mode enabled until the uv build backend becomes a stable feature: ```console $ UV_PREVIEW=1 python3 -m pip install -e . ``` ### Updating Package Boilerplate This project uses `cruft` to keep boilerplate (i.e., configuration, contribution guidelines, documentation configuration) up-to-date with the upstream cookiecutter package. Update with the following: ```console python3 -m pip install cruft cruft update ``` More info on Cruft's update command is available [here](https://github.com/cruft/cruft?tab=readme-ov-file#updating-a-project). ### 🥼 Testing After cloning the repository and installing `tox` with `python3 -m pip install tox tox-uv`, the unit tests in the `tests/` folder can be run reproducibly with: ```console tox -e py ``` Additionally, these tests are automatically re-run with each commit in a [GitHub Action](https://github.com/biopragmatics/curies/actions?query=workflow%3ATests). ### 📖 Building the Documentation The documentation can be built locally using the following: ```console git clone git+https://github.com/biopragmatics/curies.git cd curies tox -e docs open docs/build/html/index.html ``` The documentation automatically installs the package as well as the `docs` extra specified in the [`pyproject.toml`](pyproject.toml). `sphinx` plugins like `texext` can be added there. Additionally, they need to be added to the `extensions` list in [`docs/source/conf.py`](docs/source/conf.py). The documentation can be deployed to [ReadTheDocs](https://readthedocs.io) using [this guide](https://docs.readthedocs.io/en/stable/intro/import-guide.html). The [`.readthedocs.yml`](.readthedocs.yml) YAML file contains all the configuration you'll need. You can also set up continuous integration on GitHub to check not only that Sphinx can build the documentation in an isolated environment (i.e., with `tox -e docs-test`) but also that [ReadTheDocs can build it too](https://docs.readthedocs.io/en/stable/pull-requests.html). #### Configuring ReadTheDocs 1. Log in to ReadTheDocs with your GitHub account to install the integration at https://readthedocs.org/accounts/login/?next=/dashboard/ 2. Import your project by navigating to https://readthedocs.org/dashboard/import then clicking the plus icon next to your repository 3. You can rename the repository on the next screen using a more stylized name (i.e., with spaces and capital letters) 4. Click next, and you're good to go! ### 📦 Making a Release #### Configuring Zenodo [Zenodo](https://zenodo.org) is a long-term archival system that assigns a DOI to each release of your package. 1. Log in to Zenodo via GitHub with this link: https://zenodo.org/oauth/login/github/?next=%2F. This brings you to a page that lists all of your organizations and asks you to approve installing the Zenodo app on GitHub. Click "grant" next to any organizations you want to enable the integration for, then click the big green "approve" button. This step only needs to be done once. 2. Navigate to https://zenodo.org/account/settings/github/, which lists all of your GitHub repositories (both in your username and any organizations you enabled). Click the on/off toggle for any relevant repositories. When you make a new repository, you'll have to come back to this After these steps, you're ready to go! After you make "release" on GitHub (steps for this are below), you can navigate to https://zenodo.org/account/settings/github/repository/biopragmatics/curies to see the DOI for the release and link to the Zenodo record for it. #### Registering with the Python Package Index (PyPI) You only have to do the following steps once. 1. Register for an account on the [Python Package Index (PyPI)](https://pypi.org/account/register) 2. Navigate to https://pypi.org/manage/account and make sure you have verified your email address. A verification email might not have been sent by default, so you might have to click the "options" dropdown next to your address to get to the "re-send verification email" button 3. 2-Factor authentication is required for PyPI since the end of 2023 (see this [blog post from PyPI](https://blog.pypi.org/posts/2023-05-25-securing-pypi-with-2fa/)). This means you have to first issue account recovery codes, then set up 2-factor authentication 4. Issue an API token from https://pypi.org/manage/account/token #### Configuring your machine's connection to PyPI You have to do the following steps once per machine. ```console $ uv tool install keyring $ keyring set https://upload.pypi.org/legacy/ __token__ $ keyring set https://test.pypi.org/legacy/ __token__ ``` Note that this deprecates previous workflows using `.pypirc`. #### Uploading to PyPI After installing the package in development mode and installing `tox` with `python3 -m pip install tox tox-uv`, run the following from the console: ```console tox -e finish ``` This script does the following: 1. Uses [bump-my-version](https://github.com/callowayproject/bump-my-version) to switch the version number in the `pyproject.toml`, `CITATION.cff`, `src/curies/version.py`, and [`docs/source/conf.py`](docs/source/conf.py) to not have the `-dev` suffix 2. Packages the code in both a tar archive and a wheel using [`uv build`](https://docs.astral.sh/uv/guides/publish/#building-your-package) 3. Uploads to PyPI using [`uv publish`](https://docs.astral.sh/uv/guides/publish/#publishing-your-package). 4. Push to GitHub. You'll need to make a release going with the commit where the version was bumped. 5. Bump the version to the next patch. If you made big changes and want to bump the version by minor, you can use `tox -e bumpversion -- minor` after. #### Releasing on GitHub 1. Navigate to https://github.com/biopragmatics/curies/releases/new to draft a new release 2. Click the "Choose a Tag" dropdown and select the tag corresponding to the release you just made 3. Click the "Generate Release Notes" button to get a quick outline of recent changes. Modify the title and description as you see fit 4. Click the big green "Publish Release" button This will trigger Zenodo to assign a DOI to your release as well.
biopragmatics-curies-aa8bd37/docs/000077500000000000000000000000001525104130300172435ustar00rootroot00000000000000biopragmatics-curies-aa8bd37/docs/make_schema.py000066400000000000000000000017231525104130300220550ustar00rootroot00000000000000"""Generate a JSON schema for extended prefix maps.""" import json from pathlib import Path from pydantic.json_schema import models_json_schema from curies import Records HERE = Path(__file__).parent.resolve() PATH = HERE.joinpath("schema.json") TITLE = "Extended Prefix Map" DESCRIPTION = ( """\ An extended prefix map is a generalization of a prefix map that includes synonyms for URI prefixes and CURIE prefixes. """.strip() .replace("\n", " ") .replace(" ", " ") ) URL = "https://w3id.org/biopragmatics/schema/epm.json" def main() -> None: """Generate a JSON schema for extended prefix maps.""" rv = { "$schema": "http://json-schema.org/draft-07/schema#", "$id": URL, } _, schema_dict = models_json_schema( [(Records, "validation")], title=TITLE, description=DESCRIPTION, ) rv.update(schema_dict) PATH.write_text(json.dumps(rv, indent=2) + "\n") if __name__ == "__main__": main() biopragmatics-curies-aa8bd37/docs/schema.json000066400000000000000000000035271525104130300214050ustar00rootroot00000000000000{ "$schema": "http://json-schema.org/draft-07/schema#", "$id": "https://w3id.org/biopragmatics/schema/epm.json", "$defs": { "Record": { "description": "A record of some prefixes and their associated URI prefixes.\n\n.. seealso:: https://github.com/cthoyt/curies/issues/70", "properties": { "prefix": { "description": "The canonical CURIE prefix, used in the reverse prefix map", "title": "CURIE prefix", "type": "string" }, "uri_prefix": { "description": "The canonical URI prefix, used in the forward prefix map", "title": "URI prefix", "type": "string" }, "prefix_synonyms": { "items": { "type": "string" }, "title": "CURIE prefix synonyms", "type": "array" }, "uri_prefix_synonyms": { "items": { "type": "string" }, "title": "URI prefix synonyms", "type": "array" }, "pattern": { "anyOf": [ { "type": "string" }, { "type": "null" } ], "default": null, "description": "The regular expression pattern for entries in this semantic space. Warning: this is an experimental feature.", "title": "Pattern" } }, "required": [ "prefix", "uri_prefix" ], "title": "Record", "type": "object" }, "Records": { "description": "A list of records.", "items": { "$ref": "#/$defs/Record" }, "title": "Records", "type": "array" } }, "title": "Extended Prefix Map", "description": "An extended prefix map is a generalization of a prefix map that includes synonyms for URI prefixes and CURIE prefixes." } biopragmatics-curies-aa8bd37/docs/source/000077500000000000000000000000001525104130300205435ustar00rootroot00000000000000biopragmatics-curies-aa8bd37/docs/source/api.rst000066400000000000000000000002131525104130300220420ustar00rootroot00000000000000############### API Reference ############### .. automodapi:: curies :no-heading: .. automodapi:: curies.dataframe :no-heading: biopragmatics-curies-aa8bd37/docs/source/conf.py000066400000000000000000000203121525104130300220400ustar00rootroot00000000000000"""Configuration file for the Sphinx documentation builder. This file does only contain a selection of the most common options. For a full list see the documentation: http://www.sphinx-doc.org/en/master/config -- Path setup -------------------------------------------------------------- If extensions (or modules to document with autodoc) are in another directory, add these directories to ``sys.path`` here. If the directory is relative to the documentation root, use ``os.path.abspath`` to make it absolute, like shown here. """ import os import re import sys from datetime import date sys.path.insert(0, os.path.abspath("../../src")) # -- Project information ----------------------------------------------------- project = "curies" copyright = f"{date.today().year}, Charles Tapley Hoyt" author = "Charles Tapley Hoyt" # The full version, including alpha/beta/rc tags. release = "0.15.1" # The short X.Y version. parsed_version = re.match( r"(?P\d+)\.(?P\d+)\.(?P\d+)(?:-(?P[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+(?P[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?", release, ) version = parsed_version.expand(r"\g.\g.\g") if parsed_version.group("release"): tags.add("prerelease") # noqa:F821 # See https://about.readthedocs.com/blog/2024/07/addons-by-default/ # Define the canonical URL if you are using a custom domain on Read the Docs html_baseurl = os.environ.get("READTHEDOCS_CANONICAL_URL", "") # See https://about.readthedocs.com/blog/2024/07/addons-by-default/ # Tell Jinja2 templates the build is running on Read the Docs if os.environ.get("READTHEDOCS", "") == "True": if "html_context" not in globals(): html_context = {} html_context["READTHEDOCS"] = True # -- General configuration --------------------------------------------------- # If your documentation needs a minimal Sphinx version, state it here. # # needs_sphinx = '1.0' # If true, the current module name will be prepended to all description # unit titles (such as .. function::). add_module_names = False # A list of prefixes that are ignored when creating the module index. (new in Sphinx 0.6) modindex_common_prefix = ["curies."] # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ "sphinx.ext.autosummary", "sphinx.ext.autodoc", "sphinx.ext.coverage", "sphinx.ext.intersphinx", "sphinx.ext.todo", "sphinx.ext.mathjax", "sphinx.ext.viewcode", "sphinx_automodapi.automodapi", "sphinx_automodapi.smart_resolver", # 'texext', ] # generate autosummary pages autosummary_generate = True # Add any paths that contain templates here, relative to this directory. templates_path = ["_templates"] # The suffix(es) of source filenames. # You can specify multiple suffix as a list of string: # # source_suffix = ['.rst', '.md'] source_suffix = { ".rst": "restructuredtext", } # The master toctree document. master_doc = "index" # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. # # This is also used if you do content translation via gettext catalogs. # Usually you set "language" from the command line for these cases. language = "en" # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This pattern also affects html_static_path and html_extra_path. exclude_patterns = [] # The name of the Pygments (syntax highlighting) style to use. pygments_style = "sphinx" # -- Options for HTML output ------------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. # html_theme = "sphinx_rtd_theme" # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. # # html_theme_options = {} # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". # html_static_path = ['_static'] # Custom sidebar templates, must be a dictionary that maps document names # to template names. # # The default sidebars (for documents that don't match any pattern) are # defined by theme itself. Builtin themes are using these templates by # default: ``['localtoc.html', 'relations.html', 'sourcelink.html', # 'searchbox.html']``. # # html_sidebars = {} # The name of an image file (relative to this directory) to place at the top # of the sidebar. # if os.path.exists("logo.png"): html_logo = "logo.png" # -- Options for HTMLHelp output --------------------------------------------- # Output file base name for HTML help builder. htmlhelp_basename = "curies_doc" # -- Options for LaTeX output ------------------------------------------------ # latex_elements = { # The paper size ('letterpaper' or 'a4paper'). # # 'papersize': 'letterpaper', # # The font size ('10pt', '11pt' or '12pt'). # # 'pointsize': '10pt', # # Additional stuff for the LaTeX preamble. # # 'preamble': '', # # Latex figure (float) alignment # # 'figure_align': 'htbp', # } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, # author, documentclass [howto, manual, or own class]). # latex_documents = [ # ( # master_doc, # 'curies.tex', # 'CURIEs Documentation', # author, # 'manual', # ), # ] # -- Options for manual page output ------------------------------------------ # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ ( master_doc, "curies", "CURIEs Documentation", [author], 1, ), ] # -- Options for Texinfo output ---------------------------------------------- # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ ( master_doc, "curies", "CURIEs Documentation", author, "Charles Tapley Hoyt", "Idiomatic conversion between URIs and compact URIs (CURIEs)", "Miscellaneous", ), ] # -- Options for Epub output ------------------------------------------------- # Bibliographic Dublin Core info. # epub_title = project # The unique identifier of the text. This can be a ISBN number # or the project homepage. # # epub_identifier = '' # A unique identification for the text. # # epub_uid = '' # A list of files that should not be packed into the epub file. # epub_exclude_files = ['search.html'] # -- Extension configuration ------------------------------------------------- # -- Options for intersphinx extension --------------------------------------- # Example configuration for intersphinx: refer to the Python standard library. # Note: don't add trailing slashes, since sphinx adds "/objects.inv" to the end intersphinx_mapping = { "python": ("https://docs.python.org/3", None), "bioregistry": ("https://bioregistry.readthedocs.io/en/stable", None), "pandas": ("https://pandas.pydata.org/docs", None), "flask": ("https://flask.palletsprojects.com/en/stable", None), "pydantic": ("https://docs.pydantic.dev/latest", None), "httpx2": ("https://httpx2.pydantic.dev", None), # "fastapi": ("https://fastapi.tiangolo.com/", None), # "gunicorn": ("https://docs.gunicorn.org/", None), # "uvicorn": ("https://www.uvicorn.org/", None), "prefixmaps": ("https://linkml.io/prefixmaps", None), "rdflib": ("https://rdflib.readthedocs.io/en/stable", None), "sssom": ("https://mapping-commons.github.io/sssom-py", None), # "sqlalchemy": ("https://docs.sqlalchemy.org/en/20", None), # "sqlmodel": ("https://sqlmodel.tiangolo.com", None), } autoclass_content = "both" # Don't sort alphabetically, explained at: # https://stackoverflow.com/questions/37209921/python-how-not-to-sort-sphinx-output-in-alphabetical-order autodoc_member_order = "bysource" todo_include_todos = True todo_emit_warnings = True biopragmatics-curies-aa8bd37/docs/source/database.rst000066400000000000000000000001571525104130300230440ustar00rootroot00000000000000########## Database ########## .. automodapi:: curies.database :no-inheritance-diagram: :no-heading: biopragmatics-curies-aa8bd37/docs/source/dataframe.rst000066400000000000000000000047111525104130300232240ustar00rootroot00000000000000######################### Working with Dataframes ######################### *********** Filtering *********** In the following examples, we'll use a dataframe representing semantic mappings between disease ontologies in the SSSOM format: ============ =============== =============== ============================ subject_id predicate_id object_id mapping_justification ============ =============== =============== ============================ DOID:0080795 skos:exactMatch EFO:0003029 semapv:ManualMappingCuration DOID:0080795 skos:exactMatch mesh:D015471 semapv:ManualMappingCuration DOID:0080799 skos:exactMatch EFO:1000527 semapv:ManualMappingCuration DOID:0080808 skos:exactMatch mesh:D000069295 semapv:ManualMappingCuration ============ =============== =============== ============================ To get the set of unique prefixes appearing in a column, use :func:`curies.dataframe.get_df_unique_prefixes`: .. code-block:: python from curies.dataframe import get_df_unique_prefixes df = ... prefixes = get_df_unique_prefixes(df, column="object_id") assert prefixes == {"EFO", "mesh"} To filter to objects that use EFO, use :func:`curies.dataframe.filter_df_by_prefixes`: .. code-block:: python from curies.dataframe import filter_df_by_prefixes df = ... df = filter_df_by_prefixes(df, column="object_id", prefixes=["efo"]) ============ =============== =========== ============================ subject_id predicate_id object_id mapping_justification ============ =============== =========== ============================ DOID:0080795 skos:exactMatch EFO:0003029 semapv:ManualMappingCuration DOID:0080799 skos:exactMatch EFO:1000527 semapv:ManualMappingCuration ============ =============== =========== ============================ To filter to rows that have the subject ``DOID:0080795``, use :func:`curies.dataframe.filter_df_by_curies`: .. code-block:: python from curies.dataframe import filter_df_by_curies df = ... df = filter_df_by_curies(df, column="subjects_id", curies=["DOID:0080795"]) ============ =============== ============ ============================ subject_id predicate_id object_id mapping_justification ============ =============== ============ ============================ DOID:0080795 skos:exactMatch EFO:0003029 semapv:ManualMappingCuration DOID:0080795 skos:exactMatch mesh:D015471 semapv:ManualMappingCuration ============ =============== ============ ============================ biopragmatics-curies-aa8bd37/docs/source/discovery.rst000066400000000000000000000331541525104130300233120ustar00rootroot00000000000000###################### URI Prefix Discovery ###################### .. automodule:: curies.discovery ******************************************* Discovering URI Prefixes from an Ontology ******************************************* A common place where discovering URI prefixes is important is when working with new ontologies. In the following example, we look at the `Academic Event Ontology (AEON) `_. This is an ontology developed under OBO Foundry principles describing academic events. Accordingly, it includes many URI references to terms in OBO Foundry ontologies. In this tutorial, we use :func:`curies.discover` (and then :func:`curies.discover_from_rdf` as a nice convenience function) to load the ontology in the RDF/XML format and discover putative URI prefixes. .. code-block:: python import curies from curies.discovery import get_uris_from_rdf ONTOLOGY_URL = "https://raw.githubusercontent.com/tibonto/aeon/main/aeon.owl" uris = get_uris_from_rdf(ONTOLOGY_URL, format="xml") discovered_converter = curies.discover(uris) # note, these two steps can be combine with curies.discover_from_rdf, # and we'll do that in the following examples We discovered the fifty URI prefixes in the following table. Many of them appear to be OBO Foundry URI prefixes or semantic web prefixes, so in the next step, we'll use prior knowledge to reduce the false discovery rate. ============ ============================================================================== curie_prefix uri_prefix ============ ============================================================================== ns1 ``http://ontologydesignpatterns.org/wiki/Community:Parts_and_`` ns2 ``http://protege.stanford.edu/plugins/owl/protege#`` ns3 ``http://purl.obolibrary.org/obo/AEON_`` ns4 ``http://purl.obolibrary.org/obo/APOLLO_SV_`` ns5 ``http://purl.obolibrary.org/obo/BFO_`` ns6 ``http://purl.obolibrary.org/obo/CRO_`` ns7 ``http://purl.obolibrary.org/obo/ENVO_`` ns8 ``http://purl.obolibrary.org/obo/IAO_`` ns9 ``http://purl.obolibrary.org/obo/ICO_`` ns10 ``http://purl.obolibrary.org/obo/NCBITaxon_`` ns11 ``http://purl.obolibrary.org/obo/OBIB_`` ns12 ``http://purl.obolibrary.org/obo/OBI_`` ns13 ``http://purl.obolibrary.org/obo/OMO_`` ns14 ``http://purl.obolibrary.org/obo/OOSTT_`` ns15 ``http://purl.obolibrary.org/obo/RO_`` ns16 ``http://purl.obolibrary.org/obo/TXPO_`` ns17 ``http://purl.obolibrary.org/obo/bfo/axiom/`` ns18 ``http://purl.obolibrary.org/obo/valid_for_`` ns19 ``http://purl.obolibrary.org/obo/valid_for_go_`` ns20 ``http://purl.obolibrary.org/obo/valid_for_go_annotation_`` ns21 ``http://purl.obolibrary.org/obo/wikiCFP_`` ns22 ``http://purl.org/dc/elements/1.1/`` ns23 ``http://purl.org/dc/terms/`` ns24 ``http://usefulinc.com/ns/doap#`` ns25 ``http://wiki.geneontology.org/index.php/Involved_`` ns26 ``http://www.geneontology.org/formats/oboInOwl#`` ns27 ``http://www.geneontology.org/formats/oboInOwl#created_`` ns28 ``http://www.w3.org/1999/02/22-rdf-syntax-ns#`` ns29 ``http://www.w3.org/2000/01/rdf-schema#`` ns30 ``http://www.w3.org/2001/XMLSchema#`` ns31 ``http://www.w3.org/2002/07/owl#`` ns32 ``http://www.w3.org/2003/11/swrl#`` ns33 ``http://www.w3.org/2004/02/skos/core#`` ns34 ``http://www.w3.org/ns/prov#`` ns35 ``http://xmlns.com/foaf/0.1/`` ns36 ``https://en.wikipedia.org/wiki/Allen%27s_interval_`` ns37 ``https://groups.google.com/d/msg/bfo-owl-devel/s9Uug5QmAws/ZDRnpiIi_`` ns38 ``https://ror.org/`` ns39 ``https://w3id.org/scholarlydata/ontology/conference-ontology.owl#`` ns40 ``https://w3id.org/seo#`` ns41 ``https://www.confident-conference.org/index.php/Academic_Field:Information_`` ns42 ``https://www.confident-conference.org/index.php/Event:VIVO_`` ns43 ``https://www.confident-conference.org/index.php/Event:VIVO_2021_`` ns44 ``https://www.confident-conference.org/index.php/Event:VIVO_2021_orga_`` ns45 ``https://www.confident-conference.org/index.php/Event:VIVO_2021_talk1_`` ns46 ``https://www.confident-conference.org/index.php/Event:VIVO_2021_talk2_`` ns47 ``https://www.confident-conference.org/index.php/Event_Series:VIVO_`` ns48 ``https://www.wikidata.org/wiki/`` ns49 ``https://www.wikidata.org/wiki/Wikidata:Property_proposal/colocated_`` ns50 ``urn:swrl#`` ============ ============================================================================== In the following block, we chain together (extended) prefix maps from the OBO Foundry as well as a "semantic web" prefix map to try and reduce the number of false positives by passing them through the ``converter`` keyword argument. .. code-block:: python import curies ONTOLOGY_URL = "https://raw.githubusercontent.com/tibonto/aeon/main/aeon.owl" SEMWEB_URL = "https://raw.githubusercontent.com/biopragmatics/bioregistry/main/exports/contexts/semweb.context.jsonld" base_converter = curies.chain( [ curies.load_jsonld_context(SEMWEB_URL), curies.get_obo_converter(), ] ) discovered_converter = curies.discover_from_rdf( ONTOLOGY_URL, format="xml", converter=base_converter ) We reduced the number of putative URI prefixes in half in the following table. However, we can still identify some putative URI prefixes that likely would have appeared in a more comprehensive (extended) prefix map such as the Bioregistry such as: - ``https://ror.org/`` for the `Research Organization Registry (ROR) `_ - ``https://w3id.org/seo#`` for the `Scientific Event Ontology (SEO) `_ - ``http://usefulinc.com/ns/doap#`` for the `Description of a Project (DOAP) vocabulary `_ Despite this, we're on our way! It's also obvious that several of the remaining putative URI prefixes come from non-standard usage of the OBO PURL system (e.g., ``http://purl.obolibrary.org/obo/valid_for_go_annotation_``) and some are proper false positives due to using ``_`` as a delimiter (e.g., ``https://www.confident-conference.org/index.php/Event:VIVO_2021_talk2_``). ============ ============================================================================== curie_prefix uri_prefix ============ ============================================================================== ns1 ``http://ontologydesignpatterns.org/wiki/Community:Parts_and_`` ns2 ``http://protege.stanford.edu/plugins/owl/protege#`` ns3 ``http://purl.obolibrary.org/obo/AEON_`` ns4 ``http://purl.obolibrary.org/obo/bfo/axiom/`` ns5 ``http://purl.obolibrary.org/obo/valid_for_`` ns6 ``http://purl.obolibrary.org/obo/valid_for_go_`` ns7 ``http://purl.obolibrary.org/obo/valid_for_go_annotation_`` ns8 ``http://purl.obolibrary.org/obo/wikiCFP_`` ns9 ``http://usefulinc.com/ns/doap#`` ns10 ``http://wiki.geneontology.org/index.php/Involved_`` ns11 ``https://en.wikipedia.org/wiki/Allen%27s_interval_`` ns12 ``https://groups.google.com/d/msg/bfo-owl-devel/s9Uug5QmAws/ZDRnpiIi_`` ns13 ``https://ror.org/`` ns14 ``https://w3id.org/scholarlydata/ontology/conference-ontology.owl#`` ns15 ``https://w3id.org/seo#`` ns16 ``https://www.confident-conference.org/index.php/Academic_Field:Information_`` ns17 ``https://www.confident-conference.org/index.php/Event:VIVO_`` ns18 ``https://www.confident-conference.org/index.php/Event:VIVO_2021_`` ns19 ``https://www.confident-conference.org/index.php/Event:VIVO_2021_orga_`` ns20 ``https://www.confident-conference.org/index.php/Event:VIVO_2021_talk1_`` ns21 ``https://www.confident-conference.org/index.php/Event:VIVO_2021_talk2_`` ns22 ``https://www.confident-conference.org/index.php/Event_Series:VIVO_`` ns23 ``https://www.wikidata.org/wiki/`` ns24 ``https://www.wikidata.org/wiki/Wikidata:Property_proposal/colocated_`` ns25 ``urn:swrl#`` ============ ============================================================================== As a final step in our iterative journey of URI prefix discovery, we're going to use a cutoff for a minimum of two appearances of a URI prefix to reduce the most spurious false positives. .. code-block:: python import curies ONTOLOGY_URL = "https://raw.githubusercontent.com/tibonto/aeon/main/aeon.owl" SEMWEB_URL = "https://raw.githubusercontent.com/biopragmatics/bioregistry/main/exports/contexts/semweb.context.jsonld" base_converter = curies.chain( [ curies.load_jsonld_context(SEMWEB_URL), curies.get_obo_converter(), ] ) discovered_converter = curies.discover_from_rdf( ONTOLOGY_URL, format="xml", converter=base_converter, cutoff=2 ) We have reduced the list to a manageable set of 9 putative URI prefixes in the following table. ============ ========================================================================= curie_prefix uri_prefix ============ ========================================================================= ns1 ``http://purl.obolibrary.org/obo/AEON_`` ns2 ``http://purl.obolibrary.org/obo/bfo/axiom/`` ns3 ``http://purl.obolibrary.org/obo/valid_for_go_`` ns4 ``https://w3id.org/scholarlydata/ontology/conference-ontology.owl#`` ns5 ``https://w3id.org/seo#`` ns6 ``https://www.confident-conference.org/index.php/Event:VIVO_2021_`` ns7 ``https://www.confident-conference.org/index.php/Event:VIVO_2021_talk1_`` ns8 ``https://www.confident-conference.org/index.php/Event:VIVO_2021_talk2_`` ns9 ``urn:swrl#`` ============ ========================================================================= Here are the calls to be made: - ``ns1`` represents the AEON vocabulary itself and should be given the ``aeon`` prefix. - ``ns2`` and ``ns3``` are all false positives - ``ns6``, ``ns7``, and ``ns8`` are a tricky case - they have a meaningful overlap that can't be easily automatically detected (yet). In this case, it makes the most sense to add the shortest one manually to the base converter with some unique name (don't use ``ns6`` as it will cause conflicts later), like in: .. code-block:: python base_converter = curies.chain( [ curies.load_jsonld_context(SEMWEB_URL), curies.get_obo_converter(), curies.load_prefix_map( { "confident_event_vivo_2021": "https://www.confident-conference.org/index.php/Event:VIVO_2021_" } ), ] ) In reality, these are all part of the `ConfIDent Event `_ vocabulary, which has the URI prefix ``https://www.confident-conference.org/index.php/Event:``. - ``ns4`` represents the `Conference Ontology `_ and should be given the ``conference`` prefix. - ``ns5`` represents the `Scientific Event Ontology (SEO) `_ and should be given the ``seo`` prefix. - ``ns9`` represents the `Semantic Web Rule Language `_, though using URNs is an interesting choice in serialization. After we've made these calls, it's a good idea to write an (extended) prefix map. In this case, since we aren't working with CURIE prefix synonyms nor URI prefix synonyms, it's okay to write a simple prefix map or a JSON-LD context without losing information. .. note:: Postscript: throughout this guide, we used the following Python code to create the RST tables: .. code-block:: python def print_converter(converter) -> None: from tabulate import tabulate rows = sorted( [ (record.prefix, f"``{record.uri_prefix}``") for record in discovered_converter.records ], key=lambda t: int(t[0].removeprefix("ns")), ) print(tabulate(rows, headers=["curie_prefix", "uri_prefix"], tablefmt="rst")) ************************************************************************* Just Make It Work, or, A Guide to Being a Questionable Semantic Citizen ************************************************************************* The goal of the :mod:`curies` package is to provide the tools towards making semantically well-defined data, which has a meaningful (extended) prefix map associated with it. Maybe you're in an organization that doesn't really care about the utility of nice prefix maps, and just wants to get the job done where you need to turn URIs into _some_ CURIEs. Here's a recipe for doing this, based on the last example with AEON: .. code-block:: python import curies ONTOLOGY_URL = "https://raw.githubusercontent.com/tibonto/aeon/main/aeon.owl" # Use the Bioregistry as a base prefix since it's the most comprehensive one base_converter = curies.get_bioregistry_converter() # Only discover what the Bioregistry doesn't already have discovered_converter = curies.discover_from_rdf( ONTOLOGY_URL, format="xml", converter=base_converter ) # Chain together the base converter with the discoveries augmented_converter = curies.chain([base_converter, discovered_converter]) With the augmented converter, you can now convert all URIs in the ontology into CURIEs. They will have a smattering of unintelligible prefixes with no meaning, but at least the job is done! biopragmatics-curies-aa8bd37/docs/source/img/000077500000000000000000000000001525104130300213175ustar00rootroot00000000000000biopragmatics-curies-aa8bd37/docs/source/img/trie.png000066400000000000000000004665621525104130300230130ustar00rootroot00000000000000PNG  IHDRAsIDATx^}\e}&!j0 T/PAEj ZhUhˍ"U-PR(PVC$DL@BF2:$̹cLЎƤ&&OzocS.ԌJWS5&uxj=&xE4ؿJcͩRϧa^RO{ʟUv_D㕸ק|m\P.^5 SoN68Q[%S e4F/~Z`长]x ,5.kR+||镟+\B|@)ϥE>xEOdRjZGMm\SDs6SRs"/5ݝ:9$]?IMO=P9=4iRַ8YgUkկ~1cFO]]q76uo}k=הזFotA=v=w3U>H%*/#%vء8ciӦ]vY?Ž[,].K,.g:ujg?057ԄSZ9$iV\yO~ay7V9qW\Qz~^CXSPcrVʇrHq3g,.kwVXQy%\vƍ~AnM@4#rX̙3XfMu7Xz=]tQg WA^HnC&[rJqo<\ʷCD[[Ínرf*IEG?Ǯxnbs{uj:ҫRύըQN:~PZq2@+W<O<1>Λũm[>z:p}݋K.x駫[&h鲥Ō37M -KMK(\-W7Kٳ{>Ky_|h+π܄ s=XhQud,^ gFҺRK-|۠ve//}fR~V5\SHh9OзAM7TY?"}o 0:s{n]w-:o)k4iR|n`sjx50lVN Ao5)oWַUN>6#SOF> QF^xaVZcƌɞ _0,^8np ł !7Mqg6#UCfǺuAs̩tﾻ8`/3t|K.XfMu#uww3f(FlYŘّsc)~_WwAFEy{c*v|6"ۄ 뮿2]{eݜzUՇ"QGOSO{lv y0`oI-||7@lG_VF>۞{Y<՝5o޼b}TޣP+5-oNJ+WV=9Sj4)#ꪫ{lkfcKQԥjw}wuÃMrykm}-5&`"ivGO?tuAx4=48/Jg#Z}#)fj??dn%#H9xooV`H}K__#@3" n5jTv_>6*uecY;={vuaӟ^ޟhqRHg[mUqW8,b„ }=>t#lm-zՃ>XL81_yG>iGyAKxNJ׾}><&A]v٥Xpaus` W hc{| myu%r._^iEN`mV>og?9,uoWmǏ/~_V5h s-ƍtOj|@J}+ѫ1cs̩njVbOߌYǮ>[[YfezH@ ȇڦO^Р]uU}OY98ZU??U3sNvӓZ|ܪoona͚5 'ԘG8bʕ :s=WO ho~q{AG]?>;}&6 Y͚5AG۳sO^|=/m F/}Ky觯lD>^v] F׻ޕ~:*`20*k+,YR`DYti;d磏^0L.| T(~g磟. oIuG>Xes9 F|395`K=XV_0\xӛޔ>z(e|#UVWWW1o޼$s9#sGg ?H|ʺ袋 . ;7}2Av}T6@ʷG<5U,\c9SsVө g#MVݰM<;g}TBk|4>g:855jԨ'W&o~s筦_'G>6e} gyfv~N=T ŧz[`ѣsWC1}xg#Sֹ[ݬA~6;w}tt@n|`jsJS~vy֪篦;ju)T*`|C_PȇxSC`ܹXDŽȇNZݨ!tQGe簦z]R֏> Yfe簏>gJM.EwwwuPy^g籦^IY_0 .<ȇ'|Kà<{G#ԂȇU7)`=eMƙ`G[oGG?Qv.#őHMmŚ5k{038q|`Dz"|3- MϚ3]mF#lggoȇvqǢCAywatQ0̏|8jsΩnPftYge紦yGﾻ?/~fo -<'NkM'#MFMr) h'|rv^k>L=` ^uwZu_ךV^tC#.]Zݝdɒс@LCQSrHusZȁۚȇ/T&\pٹo:EMqս h!v[vnkz&5&X{E>e-_7-5`<;5g@+qqU7&EuwwcǎqMo :D> 5uaU7&z9]@ǹ aO~} hagqFvk|q07ӧg縦XPSw}wu_Zٳs\(&a˗W%-]4;5NmtE> 55~cf繦LRݕ6>d繦}BMp ] h|vk:>gE>5u9Tw% uYyc\ 7+";5]t"9sfuW7ߜ皮:O"뮻fϞ7#zGϟ :3BM-]+m駟sMKǠ5kd繏moȇ&LPݔ6[f约mȇvu׿ٹ@-!޻'md=uMoF>5uT$~ٹir|jI@y[ߚ8h{D>5uW$uMmȇwV$uQٹ@{[CPS{luOHy约 hsD>55u>:;5@{KCPS>aޛ#:C{F>\QCPSSLI@s]{CPS{wuO^{핝v D>5nU$ٹu@!!m٦'md뭷uM-#ʳ[=}#| jjٲe] hK.sMHPS>huW?cvPSsOuW]wݕ~t|j[nJ@n :3fd繦?;/;5t I'Tݕ6| ;5}  !Rݕ6pf繦CkPSm]uWV[m /|Zreu[Z؊+s\Sw%@GY0ܹs̙:έCM]{} has\ӏsqPS:0ԩSŽ<tBq|jjmK@ z뭳s\>@*a(kɒ%Ս hA/oMݩWDMr-՝ hA3goMumQS\ݙtye緦kDMva՝ hAzhv~k:-XD>55jԨbժUխ h!+W9[ӛGٳgg綦gEM]veս h!^zivnkq9򡨩SV&yٹPT٢=\usZ+tDN|,jj֬Y h3gkMSF#'?YݝO|";5"4iRuwZ.쒝ך>{G>eWnOfCe紏 FQ'"Xݟ__sZSy3ȇklF'OiM#ёGY[߃>>:2qƥ|&5uVw)`L2%;5͋YDR_ݦ!t}e簏>wS#:䓫0N:|ju|7a)k…Ս Y>N@aKY;0>f篏P1:ǥƌS,[Ug)b4/g2'E>0e]veս D^ziv>K&򑩩m٦xg0VXQlٹԖ8+)˫ah\r%yOԳMM?X|yu6Ay&LKm0uW+`\tE9 O|tjjܸqŲe˪.]Z;6;g5LuVw,`#uY/l9񩩮nYxGzR|T _|:{=\wR+"n mݖ>z6}&\CT{]YmXzu1yvWf礟0ĺRX5jԨ◿eui޼y=gzNh5rM|w}UVU0QV\Y>l0N|Ϯa0|ӟE?}$`I͊|onb0"|C?ݒZ5znczb̘1y裧S;lFUۮZ,[AGZ|y{d砟"|=1wEwwwu+R}{.h[~U^~zY@ ;\Vm\sMu3OϦ(g~{u;vw]]]ٽO/G>r6f̘bܹ Ҽycfy?]^IcWm;shѢme…Ŏ;WE>z6ybM SO=U}OOvh#oN=U{],YAK[lY~es?gb6tTjM#Xmx`|-g-=>_#֠hyVa?M]:d_| U2eݯ+Ԃh˷0B.XQit$usߧ&O\,ZfO{wv[R[X'_2FSF>"ۧ~Ճc|ȿOnł [ 4iRv^gB4ÌYO1^z89k/D[~곉's̩nr0,xbh|`zeߧηcj~Q]\1I͉٨Q3gV9Rf*FݏԶ14~k/s퐚XT5 r +oW^yeu!1cƌ@ذ} )UߺN_F>uS%ˆTJ z;Oի{ @?ImCSGJ`41?Jqٰoo{ۊ'|&YxqqGd*My/#c`#pwk{OP]km1߶n?yuÃ2{bĉ}6nsn{ mU#*_;qfՑ\UL>)?[zo jkhC"![ckuEŒ%Kkٲeʼn'OԨޕZWOh\@;:uWP]?MqY[6;wqGuZ彲g*_qjokh[~SRh\rJ-g^o'UVU>z /,gњ{ -|hwɩm+xwov R{Dk{o4^[٫bkhARG>5;e-90WX2¬\U]]]=2zU"*Gmuojem.;ӊ~ҡz#Hvl@OVh\jfN]~O"رc|+?_ V*.b-Ȟ |;Vho!S5.cV5iҤonns={*{ è'uMI=5?Ɜ:SAܹs"-|wgFVΌԟ^*ߖ6ufܱ窑|G"6;zCPmDN#g" ZzK5 r6򡦮rݩqو2!ߺ&d*ٳgWwG6i-?+b9+ǣxuY9^@SWi\6b95'fkXfMud̙3#<2{~6խgGU4.AkZ]O:oGʷ@e#ދSO=ŕW^Y,]O2D.]Z\qŤIc#[:=+uaQ]ڿq 0#(^ׂR -tYWWWq 'v[],<~ŨQ#+yFj`]n\ T_u-Lq}(ǫ"6vۭK V7L6Ђ K.y5GA_1neI 8{E '5.c=ʱ?\|k_+-ZT6Ou-Nٸ 6cT꫑Rol\F"W ;|7X<3===|{G b>zQ<Ƕ.æ00"^W ?l\ (GÿI͉C=g 9sfdɒ^ߩ߱]߹8 rO w `8TY6/|)?K>$M<8Sӧwyglٲڲ.[Zg?+oGվz[ߡPWF3`-oYCe3`]}RW18FjeÐN;w\꫋oxGn ^{m`x_)g˟᪫*;c-vqáUoh\ҵGG_"GZڻqUOs2qg~q f*bΜ9==C=mY 5v⢋.깶77mo{y7uJj`8?u-Hqtk—1Q3{a)_yzq4sԌԁm7r&秮GR;7.sO_h\B*U?gڸʷxnRV16ȟ@Z6_HuVE];Zˣ1X^iuv۴r.Wé@g(moӑuH֩H}-0TϋjjjAxQȟϺ~ڱ*EuۯdTC]i5Q=S+\˷7>#~ac7mg/Iwq] @VQgZB]P%t-R:Zs)-M{htqG57}2h_FGuۯdW!u\shʟߡ,w W7G~?@je~?rW]m/fD8%{r}G5\g▟|bxGG~ WOEg(gh>wd253Rs#"wkwr]R^}*GԱx;s/JM.O'ݓz0"{nnƿQ['2ߣ^#p{r޶qFGj~1}]SS{u—=R[7.Pj~1}ȟj{L50TfE~./|)lrﭺfv71|]jE~ʷ #;<=Qk/J`Ԛȟj[~+ ຽ/MR+1b/U50ʷܭއ _ lh|o>맩7.c1-L[C{ #m _ V׭5.c0-LxKV?{ "mͫRD~5+5q#h)`uTȟjp=nP(_]>'{[R/m\F3-ZG{u31M}W׏8R!>TkQ͵S"nh5<}n/~KaHnꗑ{u0e2:houzӟyk`su溍yKa^n aB'3m6]u0vH͋{aT`m;g#>x5 G~m:_ձϥ^^ԸbچsZӵhsǺ#p1mܙLykZh)ݿϬu0^z,{oh\F0my@V}:h5"_f`asz]˺Ji\F3*{"E (E4 1*v3 & kbCX *b׈E$%""HW&Jv{g~_?̺{34Ky1ϯ)@|*`9rqfS>@ ռ_m*mKCa3ȷϦ|:4N ~ Fo`6oeoM9*/7M@ghw߃R3k)+2hՑoz0R~vڔ, `34m#rDh EVs`(7u}[mC4. "߆9s0Z1r srhMBn*CU\|i=M,Ϩ) _玑o՜: #nrH:C[rqOS>AY]s5? V5发oMyWv:C;vL(Ϧ)G/ݵCt5? *} ~  tp7#Fo~64鶻G]Ws`(R|n50W4.3iR6,ˠv|ۮ滃z))ٯ}4n?OmGSMUYvȷjN Nxl~cv:Cr~ESGWs`(tb&kh `34i"r\e]"Ϋ)]#ߦ~  tplrnASEWs`(tSSn|n5,? `34N)D7 2+3K_ NzZ޷_:cFT~:|'e ##-#rSw=kS_:C/"ߛ))`,=&CӞ7_֯ayhJ9-)'lZz\~5 {V͑oMkXz@gh/-S~ݔCwR#a\ru_S5e$禬|[h_:CxYʩMqm2&)|).;ɑj O1z0cE>7')+˘@ύ|%gwj>0 c1Z~ KC W4{ܔ~ŨyTtSqOkP;/W{kX|@gh/S~۔Sqev|M>j  \/,> `34Nל?L#6fS_K5 ȷM=5, `34&)߉}m)w(˘`\1ۼ6g_G5 X{US/{<_:CxoE6)w\WŤȷ伔-/uTs`(#R4_:CxqN91)glSA6R )nyi䯡 OASnHyR t)ߌlY#"Fr{=nyy䯡 BS&ߔ%, `34ǭS')J*(vRG6znn}`a0&JДS~ C QW"딻VQ73]vP8o|hu)0@gpic"R4w(|[i.\Mʪ~M۽._ރ0/\~  tƨ `'4gV4{הwײ n2_׷z돟.]/hks0є Ȳy:けlڔrů0֔ RVzm}{iJ.ťɻ`ȟ{5/e$L|h5)07@g3~ +.{TWS.I٩,̱o3MTA߭l:ճ&e~MtD[\򠲌9:㎑⾜h~*)E^edeG>)L[#ռ`0&^>4)Es tF#?ٔ⾣eDdSS.MwYF jv|lS.J٠_VGy-#B~JS_ê0)?|"v/4 `МK$rqjJqGk`TD-5S#ưدi# ``,|_QW)_*b!e~M[<)MDO5);em\ef1/_3[986XCYuD_5W)w)xSnHybYOTS.N٠_3GE7S-Q\Uy`(0SՔt`Bڔ+ӯZrNUS֯#R߲-fjLw0 |bWSJ٦,n;M)s$/v5,Ul>?۔״#~k0MR>֔3S ZUnʍ)O\}1m)ߙ*7Frel"~8 SKSe2hWF~)7<_su(Քkk5կYnߏUsP`l3wS9#e )k#?]OѰ{v?"߾ru,q1򃩂eȟ[5w Q)?K}Y1z50\6֔5 ?ưܯYNDv0X@[0})? M`Z1%q4aدY(\4esqZϫS4gT&2X51دȷ|`3jS6,_FP`ة{Mqm2XZϋњť_T1lX^ٯYhrNϩ2/|/e Ƴsu=E%X(|[k n~ٔⲮȟS5 V1%٧rr,ŽWodu=EX(N")Gk "a~r Sƃ"+æo1z_5|{kKk"ܦ|_.T`(&MnhHrc'5~֔ߤ,[\w">լ ȝbsO;)e07B%mXԯYlF6%{ycs#/(/#?ݔk`1kw)KĨr=m`]sJog"7r|g7?E~)ob(.|]]SN,D4VX^wN9?)_ M`1zw~ ,WF U~Okt8`yo#GՔ[e0ce ,_F5̠?#?ܔk`}&93F?~5ů v1Foeo~ ,;6j^ #j~= =S.|mѡ @̓SrSݯ_8ӱ469w0h\~۔;ăRdrSKYQ+|;ܘu,E,威ٻ_#wᔕe)G~)G/K)o*ǭPߦ|(4&lN(0Pf8N9/K=[ͩ@ao6)^RүXwKY8ny\,"j~2 lnpx,Lhߏ/ȷa94eՑ?aB,"j~0 tS|_n! 0rI'Ue,[_R6eU~smM)k#jN :!1z]Ў)G~r)GlP{N(oG\ŰSWwCyh#ߧ~ c)E~R) _Wv9,ݯiMcob~mCyX5My{1P\O7s)e,v9,eȟ<_cUs`(A\ݔaO7( ȷa).fD+6s`(QMSwS_@9O6嫡,Flr1r8ޔ5)k҃"j :q1zx~ R4΋oSKٸ,eȷa)~)// #ϛ~ ]ʹmK{kkn?F5G cGn|oʾZ)gD~r)I٤,Vȷay~+v5 KŌT|b0#rS|=kS_@lrz'v(/K me oM*FZR4c֯YO1-#q \܃*mI)e|[ka9_߯P` =3z&K5,◓E~")'/2ȷaOY9ů_/_OS~QY6oe`x{nʚz&5,{j'p2h.Q\M%.{_iX׳": ћ/HQ'nۖe:_|t"Mrbf>]!+Fkcӯ` F~¶)?M]YsQ[e_۰دi^ռc0ȋ_zٯ`mO6唔ۗeJo|wk^ ;514 LћUX$E"?A۔YYQʥoòSYyS5)esV˳w9p0 |>hJ^{PY"?1۔3RPAk ;,׌Fe|i7 U M)6V?!۔_/06]d.Az_㰜ԯG7y`(0^ДSܯ`ŞئrDz Z^orYʭʲrruX_33 zMsCSnHyR9(ߌlSJ٦,ȷa9_3nksO}C CS&ߔ%ƭSצmYE>gT`(0#9)EFP\O6W)w)Q+C͑M.1Q1hmʯSv(Qn PzKsESMyTEˑ`moRZ 5ӯ^< pF>_4h?,jÔ/E~b)ܭ,LM 猦\~ Q6 զ\rϲ `FG>T[FoEE>o4h?,lR>Ԧ{e#yWsI5{d&M22T4? Ԧ\=CME>4hUY0Y#?qڔߥEY0+|N郡CMD>4劔]2ɰ2c0me))fj: 0壑#M)Y4E~)Nj4 0\ėW4gT\>X3]m #)|>iXchѦ\WewsL5h4LҔ{eh7M)]ё3y KJLS~CY~D~)ץ<_S}C)\Ӕ_ܥ(h7E~)7<_XSͽC'S9;e۲ }fSkIA8 `&7#srV6e@{ ͦ'k#`(*ߊ|iʙ)w\WDfSnLyr`)(򹨚;,MbKO)w(+#?ٔSկX*D>Uޛb,fTM``<M){kiIl= h6O砦,2)k#?iYO~ R+.Z`("凑CM)^`~SD~g`9TMѐX*Ŝ3ӽɧӔەeg[yN`TmCDqyS#ۖe y1Z4 euAsT5,-S~ԔlV,gEyIIz5j6 XR[ԔS6-)7E~2~ @\\U͊P%u/"rRh 1ze"j*U [>=9) .bk笩\_rNTSIY0IǦۯh"rMer.窦r `fOqMy]"˕qm}yWM9>e `7kڪD}}+ڢhՔBcSŦׯhU]\: *wNUVSruUF_\8 :wr]M964\ĦgVG>UPVG\ʆe0O"6.,ysCZkǔ"Ú 2`7ٯE>Us`(@3籦0ru' ~ @l|V郡wߔ"˚Ue0 rU' rHʊ S|NPN_#Ϛ򑔕#?IؔC"ת`(@g?iMPhX9F?axd8atm`0SfsLpLcȨ k`=C:g6Wu9"\lNq|g0ru[S M` I,M9*eUYyW9q07ݯ橸e\='ؔ\/S._SN٠, ťs]5' tڮ)|k;5V)=i ݵyocoצ<:hߋ"?הτ/0~v|k ~bu#U@W''MT-\c6s)ecAy3 0vK.)kZ-P"gW@g}:_SY&Ga|h롑{|a0`l缦_,隿SA+R.W5ů4_k,;c4Qޛ `\=2򹯚q1zx~|-袝"?Ք%pk#M){qY0/j ;O>)oը"@'4^2_or^)LJ/0_j>1 07_ׯ4S@7Mwߦ̥ |(OVSI:Ij>rH#ofTmN}Q۔4ّ|'e `"<9򹰚#Cߥ<ؔׯ\ENM[ymSr `b |XCc&ڔ 3o_Zk(pNyxSS9)oK9$~>rt-Ž;5MyASRr(x,%M%V))dzVsb5LgMk-R\`l.ʅ?{ʇSNL9?F;yP)뼔o|(Q>ϑ9*qij"۔S6-&G>/VS4MYXO.Xߩp;Y0Vo'ʓ7mQ>x-5.sKM-S~0)K٬,HʼnX;C&b&ʒm3XNֿWM7嘔+"_Tv=}d'>X*oS&pqY7nmj 89JS\w!E/ci((߃IY,G7n? E(09C&R-~[el>`l5ʓ7pSWt- ҧ""E7J/|Mcqd`!YN_+rr^ >>FyZ&? _G>WVPȥ?e;XܽSOe:[~rHbv9#eUϗռa0`2yrsx0ֿ _/@+lw/dasZ't4qRCPOsf5% xusb`TֿK_%"1)G\Bmɳjժ޽}{s{_{[>G?;د׿^?񏯫)jQ>v]yqoGGYl)[ܯ@E>oVSH`Q6ebf`/""lѳgއ?|38wWUW]1.C\c޶n=%Qjn{]n@~ϙT4O|\}Pgk 0򮔫#_-J^>O~-"w'>޾{ELټ3Aaߣ&0@nj^vHɶ\"Sֿ3讝S>rS Kqi?>o}wۿu]O;#]Nk_I9&A1^{TXߛ#+)0閳[wڭX<}=ՂX}~5k׍cx/zz{+ߗq)ߑKM`E>OVPߩL}/@;eW"_H;lIow񝸜R).uq^W/淣'R)##y-#&O[E&>ֿK`i')k#_<9mQ5yM邏NtM5{~wbx?8{?r?.w4Ij> 061~;`n6DNW?k6)^R 3S&o#m&00|N橃c"ώbaֿ3c/f7߼w.%rW6tc]t_M``}(' 7| ƃȭWEUvq>ޟzeR+K_Ry!6R\met?GM``|,򹰚' .4t>ֿcSFЙUve '[fM}EKqP 36F$ֿTR^r}䋛czo1ӻ}L6t[۔ GG>VPӵo=['/0I4#wk_bo?aw91so?=L{G>UP罶KsXN ])|3RV\{{޳:oq}6`ELhDܻwxrs_5 +ťF>=gD7X [`"_EK.~bLu>Y^9w! vls_5 +|Je˴&d be<~cNnv02YmtAϷ =fj0 0V6H9?y i1/#/0ƊE5/RfLq#8f͚1vG[jU]⾵όv[ϳ)])+`}#9Jms_h_fmL׿*I&#~v/0]vYoʶYچϏ1IX^)w jwJylʁ)'\ض>ֿۘ1u|"1oyد[_19ަnm/#ĔbEy;&SϏ8 0V<4eߔR|n\MC,?_Ԙ1SB!3xƺoB/{f͈9/eX^y-G4|rߏ|?$kkCYYcȣS|1mQMf<呱X<<2++fwuZ:V)_|1mgM7T_{oxo|%_!,#̩:+In%uAs5EcSmWC[Z-^S,~|0m?:l;!_K(Gwߜrzi)Gr őP%,!OFyQM_)ytt䋆YbEد[_8z+W̶R|I~sY&Tb0 `KXs2哑/f6r)5 ,9C>6"rseNf"_$ [l;3kX/{oyΐ_{L?FoT`Yiֿ`hp;?չz뭳u=ET`YyֿL|Q04;C .=.~l!&0++_ֿ _`|AИwܱw饗*\rl}0W0;ֿ@.Q^h̶nۥ"~};&eAU\: elYSvH$E@cb WP:a #?ȏGY_Dxߟ@W'yC _/t߳#?xoڵkŶ=//3.99C_/tS.=6lӻꪫk(W_}uo!$v@^C__讏E~ޘ0@}/?yPy5 !ֿ0Kֿ=NY{:vfɐ@<4/ ֿ0GֿS΍`=ˮڻ0nރlS6 ⑑|斑t/̃/t;"?HϲbŊyW?>{>Rom@W<^Qt/̓/=Sn=ˡZ?*9lRt"ǫ`(-g g2?pvyl/]j>rH/7SN N=l&ůh'G>Ws`(-f g"? rԏi~~4$lE>WPZ/+"?r;ܡw֏i\s5-2۟e@=+򹻚CCh)_X$ֿI]Y/׏|s!,e!򹻚CCh!_XdֿE~xo͚5z`žG=*ۯ@[cv5 aY<?p)dՐ\EF{E>oWs`(-c K|gy+^Q?/~q 6zasv52ֿ`y>ˊ+z^zi8.h>Uremyisv5o EaYxkY1<0ogCRBvyyu5~Nֿ `im}Veʕww`~߯۷[C&hWE>_WPZ/,N^;8lf>; @KX2*K /~,+jժlk)mj aYxVY>1;ַfݐ<3h"y`(-` -` `+VO xZ}k?y26ŵkY{:^Wfߐ<$h7G>GWP//,D~`嬳Ϊ!P0-S.Q^N;ecCN )~{as8g`_h!_XX`:ˑGY?6aC`ǥ9V0//,C#??~\,b߫C`:D>w[K:ZFqIK"?^//| k!GO0܇"?%Hg0/t/c"?r'׏ǁ%~7/t6NAgsCʣXBXzvm{k֬KzlllrishW6Xs9' Ki1_ R~z92!>]L!Qj>v1{3Cqv-Fa;4Ǘ/#?p^/w]zk׮r7|soʕYdv#}q>ӆjˁ8Ǥ Fa;4Ǘ/ݯ"?p^/tP83r*%Lr^0 S\ e`T|.]/ֿݣ<ެ`AsN;~MuQg9 n}Cr`T[\\֜s`4ֿcJxYzr-]^dT4'zsm9Ӷ$'lY) f wBe{;syNE^WekC֞ϧmu) fwLi?_]q#?`^/|kϲ ;fkC&zWsj&ilY1 g {BYq70,*\d`V|-9u`.إ^{K^2cgz)a ;0?~MG~Yxmݲ϶!sqs"W+:Fsb}oxx}hC9$lR )֥gRVsubszvmrm른0ݴ6dg5~6䚔 zjץƀ/쁑$gkte]}hbC`>ܺ).Ae0ֿ0`fy.f.K{0_ֿ0&`zypl:o{y֣<>mȧ4u)/ _Y N8~MGz4q} 9#XH"yv!ssSb c[zKٴZ\pAK\tEՐb8X /_իW׏i `֮]hϬ!k#g"o /_'?clZD'< g֐ eEϵIqʕB1c xMo_"~g֐w Ue oT1QfNbAQ Tj0;jb:wDo $KH^Dsayf[kf}[{}ޯU/Yk緟 3Y*mJdr2(2Կ@?3ϸk>}gyY%Edg Կ@]tؗ~_0 > zd jn*hYBk֬Q5(ZrWEQZp莱/n`vڥY@jLZ ~(m,& о*SK6mܾ5 ֭[ٳgf„ jgw݆"uj?dDnX쏒7&_4b_ !oڧAҥ*"nj?d5moPW {c/C%\! _s@.@6uƟ7. &ߘ`8~Dw}/! mݦs@n@}d6fIEYD //ӦMsՈ'T9 v}T ~֤uB 'C~5"zW~\&\d G /Ttؗ7|W#B˗oL0?Կzb_>#_a8֯_s@ E}- /[tؗ]vjDcSx 8PѝaZ_a8߯sHZ Pܨc #ˑG1 Gu@ Pܨcx*#K4"x;ԾW(nԿ1phI|F3a8~=;þjDk.R./XL3PtXu&"?Կ1pP~a_a8>C^5i2d0#&#$QC -!wqՈ7T9 KSW&66zZ/ 'ߘ`8~ߋ`_a8^}U@(3dI6wLn@: ߘ`8~;ľrnSWަM?u/Y'|]QC u!Cnp|mV|MpiJ[VV?|Ioʕ^UU۬F}+Vx≺a:v>obo%1=4*ߘ`8~Odb*Cgb?Lgˎ0Y&X:w?njB7sںnw{d8KM PB "c}xw~8  `n2;*ٶv8۰a7c oر^IIV[&#`7YIDAT_ _Dw}={ۿFD0O3gT8 ( g,N5+_͛7ϫpJԳ }Em3w;f L`8^`rwkDtm}{Scf 9s0w^|llx#_Կ1pP.1enpUa#FP8 GI_tԤٳnz;vM"hWiﯶw3b7äL ?cx$c ѕ0oq9ꨣ>jmrNmRڱ_r%믿gf}39EnM-`8^`mEwUvoڗaٻw:"hjށifNt{vʼɓ'{n,w?u/MZC /аDw}Y`F[N˰\]4|o@n3"J; f͚UWWMrlu7VB^ 7A 4l/կ~6"O>Q2,=:"讻R6 ۠2j(oɒ%nsh"sQ ?1Կ@~*~6"R˰tڵnyDgm@Ȟ.&'I+gyl2CZt7tPߙt"p|P ;YtٗRk#gXƍԸ/\uk@NȎ&E;)SOo ޻54@v,7_qT$omDc/Jݽ'x{w۷{{nZyys7vXoƍB-_\πsݞI1yZtrW^usjr@fQ9Hbe_&OsQ2Yng&MR) dVۛҢE ׿5!(Bޔ)S~`w{$̢-b /_(2zh?nZ3br@f0d&\wuuMm۶ͻkO#5&7 doc8ge_U/ln.,vr@}d6&p u@X߿:IL7E[.~Կ@ꎒYpFcU9af(  4O/E1n{r1DMMMݴXpc#<ԿEG g/?~7"7lΏ* oQ,h1&ۗF3tP;O6l9u& 4obQYtٗnݺnDzm۶j6%_XRz ]i4ӧ{nӅԩSs t7nW|&/~;*|FlݺJ?}iwQHH&3E)O>իf cTOypQ)/>{Ǣ;;ndgΜ]q^~sPމc۷7j(ou[h{ngoy{nst7Y,Mi4b#TUWW==RƵ@zōh;ξAAw< |d ,Y6U@JfG}:R&_HobQM3JtYaڵ ԝ`]t[`Z7[l ͤ@ŋh: ݢ;Ͼ)߄ {Ngx@*eKt[`RSSy8K!;TP!/"(`Կ@f(C}sYj*uz`MEo~6G@^M8Qd@0_QEI<7TrWsY4n8u>ϳuۍ<nS{Ld4_Q[k͛7}tY`5 ɋZ{uیp}㹑-G _ 7Dt'ۗ>ۻwg{:(ud0%1ۊWr R.u\7 ȝDwU Ȏ'-$#pпVfnDW_RaS _ igWtgۗ6mxn@3s#T[@HZmE`=\mHFs Կ@PC=4C3|X dv"0W^^6?@޽ׯ:&-<r&U;ݾ~ dȮ]֭[, &nNC͛( 6mڵkr@/cԿ@<"rwxMpm+$$|dvB[jEeŊuǺ{D_ )sVη/%%%އ~ᣏ>;+ $ V2uۉ̜9mz4gu7M>#@ /\|n@ƌΫ#0Mt[nmvv7Hrȿ/ W__WSHtۈ 2īrUWW{CUC9_:_p!#ү_?on@jjj޽{)$bKtҾ}{o֭n–-[>Z!aY_1θc=4`ĉ< &O ,ŋfKD/%Կ@Jiia s=Brȅۇu]n/~ u~4Կ@QdNgֺ}}I92bu䯒8Q&[D*乿@Jo< '&qG d/PN09W5kSMH9wӢ{gźuf5{NqԿ@PoGm۶0nnZ7!yR@d!0ӧOwԩS@&DwU;<;v:_BդCM։n#Tm?#>Hg*k&;*5kָ5K~:?:"s @u4)F<#n <Ο2;_ hѝvN8rk V*++#$* 2Etҿmz럺QH& PiZ~n=su^4DԊn#TV\6;o($M!@ & Ew/5 @6Bs)Կ@JdNJ-k׺P֭[lR!aY@tmm_n6=Rm6UV `_AԿ@qOt+//wk(UTTxzRAE*=Hĉy&%Կ@ _8Mݙ̅^ֺPT1}O d@pmqUVV4TUUyݺuSWH-@ $W[DwsPT&Lɧw!P?h4UT @/(nLf֬Yn^xA dI !CM&w- 4Hg!9K Dt?4-rk Җ,Y╔c\,p2ŋ@3,\Pg!Y"p/bGDwӲeKon DnZ !Mt;rg 6l:B-KԿ@*gt۲e[Kyfsn M8hBeҥn -[η8C חLwݚm۶y={TuؤLn& _F6A2謳R]@zA__/M_~Ν;(h@9q$텊}yy~Կ(zԿi_t{n{==c|v&Dd_=w //xх@h{ =FS&29h׊n/TȂ_|Q!{@__a] ^U{n JVm#aHAJLfұcGmd=:wÀ9 ._ _ ie2WtQAL${L|xm$MZ h&P[o)ϒ8 D#\xn ƌπ) Կ(ԿE C7d^vqB^1@j,Q3wLȃYf3$]RC+<'h0vZӧ l-J13LHxm/^EETvmj?6TS@7ԿrfEFHQ/WSǤT = D'|u+JWL<})(;%2_ =Կ)_]jG)++,Y8@ {tQG)Im޼yn6sLSIݗBKjĞ<@SP"Lv.>~3ʭw:555ޯkuܤr4H/vjGj>944 /@!m^th{n탘{wN8A/)fI/{Tt96](`VR0\zK@uYj!EFQ(d3b$ثA|F{sw&h:n_|Ṱrת}nm, #<]@>h_4/har~хI9cE5bbٲe^Ϟ=qbjMn1StvZCڽ{WZZayݗFZzw!@PɨD"ػtvG(RZidə1Nt;Kǎݦ 쩧R)ڵW[[< PYYL 32_QUҺuk󪫫z En VZFtȜ_Ə6i(`ڇnF[P.\< 5\]@_4@1i))jD.)[n/N_=e 9̛7mP.]_PmڴQ_ ٳg}uE@Կ E1)gʕ+: b oԨQjLNȼ/nsT6o6o(P]vnzUlwz[lq ƍ~ 2ugL]̤{իݺ  /P&dI[8OtK&>cDC7w}wvzg߂r}9 >w%Կ1F I k6cRGuGj5!0!]mP|Abαs3wSVV߿k(4\rwi@6Q/;R?][/_ܭg YGSL>+}n|yꩧ&vE?7]vwWe?ɷ ϔ)S~ -rԿw EO9餓YfqGNm?|oĈj41MNȍRrm/׭[7?;3*=RrA?_*++VZ傲i&ߺ(,v_,$r7 =L LeSRRR_ݫuk6df^iiMjI@#]_~nSqFһwow: ʄ UQ`>v[@=߈')<1Û4iyfCN'N_L͢&_ YD:.(>j^{M-vy555( ]vo@P0_,,L](5+C x o˖-nm7eNS3Yer=6ʗGym"Q`GywAw k߾Z>(Q@x2]  /d_K L]85;Æ +>=M춱nZgB0V`D3woA93U}NPF宊2|@a_HM7Lh%׳E[He$]v{/޽ۭ޽{eի>̇&W"Y09M(4 c6R,|gqoAyU}֯_ ˆ Q R|nBe{KXk/bdM5Y!XJJJ~@ŠsdΝny3f?3!yb֒-r/{m/^mmۜYF}YQQᮮ :T]dNs@ֿ͐׫6;ߐDa\;O^(Z1yEtO~M>{7r,Xwy˖-M]s5پMJquo H]m/={tWnA\yfΜ J۶m=tǪ}>7 ER%䂽:>C-l'-iǛL3w.]xcǎn-ZT7 duu[fozwu7fs} v_Lgxt6ŗѣGM/ e˖jz ;=d9o JnUtuשUQ l O7fky暤 դJtabU!ݢl0,͟*-M~?6HZRa3ܶė'J( W,(?jyaY~: >U@.%}DII@Vػ-]nQbsCr<@M;oMHɟ4f-\˗/W+,|z^'(z* sԾ G[Yf*i9ȸ;E#X|FlnJ Ltc^dW;aI@CnG|0]qj .pWM~}~^ee:>WyUP6/R l~dTCSHZe&OlI"L7m9)Lv*Ţ߻8R֬Y+ܹ+))Q+(]=%_|]y{:+R7%w{g 2pwE!6㓖+t&Ǜ\/+|K:I<94ʔL&JZ\Р*|rǕgޱUPNwk5NTKaB v*D&f ?+h%-W 쏁_7krL6{> ~b+mc/V0v?e˖ … վ |ஞ;|1Ǩ M7䮎<+--U) m@[]As1A|h;{+vvM6ydv%W&`ߋ}O%XH/ʦ]TJZ}YtK׮]$ /P :]I^Aiժw^wuQ.]~ H- 63i7 LZ$-g^&tZcrtIL;yGS'nukgr$[ܵ`/BpM3Wm/}qǓg)>׵.3gtWot?ﮎ<իGG;vMa6v;@ 2]hĔJ@٩_}؋[t{$ل ~ J-2z7瞫FP 䮊<߿G𰩠$-)9d"ʤ|;Ƥ\qj/^8-i9n/|9S$Quu׮];2~xwfy˪UՑ'r?Gs@T,{fɡ= Y(L#Ǫ:6II _ '!}՛kӦ;A33P' ' Ree6%- :E~0Jr@SA}؋ _F'!:,g7zoN?]QQᮎ<8s  ˓ M ۷ExdjwWψkתӧ#;YirXrL]LѤ$i9ًcfIۤr-oǎ3x`72`wU"e^,;掤N4n/'-*{D6$- :"nZퟠ\r%Ϫz]9"v^kv*I@#M>]D\P:};I_ '!yo²pBw---U7(W]u:r3P% ' 4^ZO%-2Yt`agDh=mn7E ~'|7A)++ﮞqv`AŻw#N9_G&nUrb;&eIQa/ZxI1mпn|9$؊+~ =㮞˗/W;,O>:rj_ov*o%- ښ|$hnr@t4.9;i9Mt'!RfƍYӳgO1_zR$ sjo6 SAb}"ضh٤GWm/s;'#Fgգ>CXx wuHΝH JM^g̙&lc^ ~>'=ExrW$,sWϪm۶qƹ#GRH 1-{䴤Ą .D^msOZ@<;%jDTVVcJȑ=z?m>6/[lqǕ/V"ʙ=i9E(I6cL>mF&--dw\ Y'P w5#w^u'PwI(Bψ.l^L^(R"طKZ@q)e޼ySr饗Y4gbgۿ,{fbryOL'-gE6v@@<<$ eĉh^YYŒ[Y(VMv9b&E6]C炽H@NOSw\ Y+}PLyݏ,O~@eln329Y?|ѣ;,ٰaŘ YpǪm>@q(l@C }b/fNɇ_#3pvEw2M&7JbUL'68;Jm{^؋&<Ĭa?:d"$qW1Orf~jnfϞ]0 @@{gC}S (n}F2wS΁D}bxŢ;nI(vP~W.%n꽆e˖-Ƞ7mr >.y"y!4Y76(Xa;sI3c7"fbdtlPX8`s>CcHDo\eRB1˂ %d؋/{X*w0}t^r#ϟy@⣃$$>Ev e}VيA"E>u|f(t|ڨ]*0ˤT)cǗ'KȰN;Mm[kѢzA)++qm{qrCnhF-SXޡ~wv6cgϲ3"rG !W !#4?6Lbc.KZ;Bp7>n|7n; z6f]{=ޥKx ~h(4(XA3 X&W%@S}s);%lǟfr$N~ Ȥ6M>>glO !R>I|m qW%FwT3YwwcƗ}KȠǫm;r![bza3f:2W^j{;@;U^V =,vu&ov].ݼ 3Y.ة7(gR$m4&'2N]6?vvϔ`/C۪Ny$j)b/XQEcB޽;irvB7p@òi&wu4See!/tri^*ii|%"m#{fI吺6gP~%1 b/CD%MN6dI%iD7{7<|ڮ %xyͣI6TcIAd_;-sr. ѯ;߮ 8wfWϯ\gBL:Um;`ƌ꽇e„ h¶v!FicK;Mp6bdzV䅐2{㍻-bgP<À}L>%M}{3 "^U~7wMz֭ήNC"4eM>pb  A L;NX֘R&Nj/O>;΄ ӧa K9ջ۵kԸ/fxv}/?N_p6SI ~ c,;漤ۧ>v\bY͂bt[6]=,o|n̻K KIjHSg N 5v*;mbdX-E-E\X cŗ.gB3-[Lm 4]]wu3:K.Q8 T/M?ԏATS lًsHOL'-_{aR)?AWR/Ww̽(NG^^-mNZ@jKsyT]#{mP܉ղ^6Xftcŗ:Lh/\mYnLDLKb6V;(.uk!U?m6MZ@9e@]㢷IXn_'Npqi&w M}vDm㠴l۳gOV%,6lpWGnېdWȹ9Ӵ @fSOAeIwؤа^n6AY^\\:0Nq墷g}n,$P2;UCR}޼}zlDWϳKxV7,7xz$<계;pWG̚5Kmۀt(~wDiiI?0\}C8{^/ەh;]tv/BK.{$'⾇c1 Jw!I?i9Ms]Za"z֯ esΩ_8`ėkoB߿;c իݗ{ײ{N|ر;ބ&xWն i)_La7o:P[[o^m׀B =lw.3H ~ >7m.LZ-mmEZ(pE_'>uX=[9v*բ5{F\g?,߮_'~AerH:/5kָNHӘ1cv 7{=2|pwu!mu-4mw2)OA6 ic-!\Ep~/MA|hY{Yp`(v?f6NZ@fϷ}E9G)ة>fuD'<CmӰn۷o3x`²~zwu(J&_iY7vZVf:;6$?]T;l/\ΕTс@a$<(̱WkAr`N|)))***ܱ'k۶ڦaYnw^UV*++ݗ@#vޭeH vL1ӃdPߡ6$-~~\+=gVk/QN>A]u`;aworc '-WlaRN>,Wra3iR%XeK/OHyԶ ˰a#oT1,/:1{lbm{@+{e_u&SϴRԽVT?6YwJKg>V)&_aB:`$rG:HӲf@؋-s&+&Aϗϧ&բWP:կglj/]t;A]w[e9ꑶzj2dwu4bرj;hũ-4L)eSw4 FpmPESaώu![NLr@.K<(;G>xց IbpFvg{w8M>;>џ5(b|[)}ez?}RZZZ7,R6m4ȧvaYf:B*U75 r@vL%-ʦ5^?KJA7nة&-կ+~Aa͛Vȣ%WPX!lrc]@٩샦4鑴\*r?kP{+쏆A?t4馛6 ^fΜ>kXHMP級Ҳn^ DpmPH&NY`R\ܥ3ur1!( E WP6X!nmln%- w9iTEΠ<}`kRjdv0e;  12%Mֿi-2%%az.s^g5? kT@<*,SO]4;H/->&XMI7LJC]@1lj_LfϞפwsI`mk]{C0-^ىb+*[,(>"Oj ^tcWP'(@gL.2>&OlÈ|L a-͹/ ,~ bob|8ԮPU{N^QiYb'vi{ǯw K~$X֜j$K~bj wkd=T*+mW$z 6~`P^ċU ԑ^ŢߩA RpePxFw)?ZHbs|ЯWYf." '۠f:i(+"^,Z,vES#iwi7oǴFM f{u6۸t׫TЁh"ћ>$l{=k`P{/->[Ӯ~]@.ŧyávE=5 K-ߡX:Mbu~دY}?"2]QdTG\:^jf@M\*"^,:-igz)}WZ <-{kN L$;bo}Jcvq ߡX^^"MƏ׭Tg>sE$X6_&kfjV@ML{V=C=ˤyb~P;ɥ7sǸ9C+b?*Cz$i5+p," `M?SA?&ڬY]ZQ5q؋xTسL=|ZDs=ˤўRx :s@: =5zHl/vݣe4~~~ @?uuu쳏9"rDmP;;JTлڥ`P]^ȋ7=ÏŮOTr=ˤz.s~_va Zŕj˝e4irλXo7WD_=Fa?shڥ `P3Oˣ;ĮO[@ Q'L uI6^,wFg%wc~- @tvv[o9"2^OAmi!i/C҆0¢z5X?W,,6Oj/@uTw=5z;}'Ų=i}.Y /4UDf 8lWu^Tлڥ `P3{!ʱ=җŮGTڳLϊH1R|*e)Svq{FS7inn|M z 4W+PdO^5Oj@ͬPżX]vv(}J8 Sb^)< fyeX]=.vEq^4o\󟁊}OZ0qDs,9;.-(T<*Y>(ŧ>.eR/u2@w=h&8;M:G=bc˯]* _33g_Pc=f1Qd6.J^vi@Nb/QgZZϏJܧB.=5 F,{>h3FH|z], F,b/v-X|_PĊ+=G SP?u_)K=*G*Qѧ2Ss,x#yePH:G媞ejWb~Vgftq?Ɂtuu5/ʕ+87:OA<(zyeP bK^أ2e%+c?,wپ{REU-yEҷ4繼OcbNHψϊ&u/W_m_6t͹vIEԍ>u_Ke4ȝ빜&)/u)svps=\:Ůs2`֒µm/ ua Zo&:ܹsО{L'' >Y,(j{q-e[)A~O)ܽ-e`X B@mPBӸb׷费 M<.)zN7'~w&Kn,µP.lx9^]3eH]PuSuMh!6?R ?e)؝|~ $]혦B7sF K9b׹/Yq2 .wJ4e)欳`@C/~a' ^߻^5Ƥ N ;$}ϋ\vӢÍb7b9(PڸU>X4>_ }g$' ~Ƹ,{rT]P_^+B_-4i _]5G@1)'w\:ĮwB5Z Oà 51!̟??6l9."%'6k^rj@l''_~H:Eop#(Ao!}P8Sb׽ѻﲎu~Agg_RmP"L EmO:bC풂0}*/b/Վw3I/}radfsfzQLr2_;?.@}MoOS>کj' F,{Y"P5N />m|v^]B)řNS~JOC]Of~ H3fDs@Gmo{׼a]Q7$G\V 5tƒ~QVNzIo)7ǁ'?#NcD5| ]VwM2LO2 U̙ӽD!67}E-bB0H}re)Ly].J)R(ߒyp9{.;%b;O$@]#ܢI{IR~nk^k^u)P)TbݢtM53 ^}`f/0p?7m}Av@}@ E j(&9<@d\n{͎;,^دt`]w5{Mz' -?yeP;Iմ|^9Fȥ%@˞{?ӯ|C1yP?ɠSA,_2#vN5:U&M%FO]=~Oh@tuuٿKDNCm#]hn3~1*ac)?h\ @L}E_~= Hs9׽k,ld9Jl@Ci7 :P9GK6@%\"@|}]qd9眠˯5Yge^> lFlBsC_NJlj^~P_Ş4dBė׻CqN8!X|_j38~Kt/ڡ6H&_jgc\hSw @mo(޼ \q>8Xd_jٲej^K-ltؾfKKP6}z.Lͅ@]Ŧ^Ux;B 2X̮k~W_}5q~Kz6H6} MF@~ syefPw=Wif4 7t'ku@E=Kt_' =6vyUl_Csf@6詟8X,C.=#d뮻ί1cƌ}z{. ~(~ E~CK6S?MlRP;}Tlj ƹ,{<)tvv;_:::gf?+#K]>!6H;44EHlgR03x_.T@P\2Ǐ,X>?~~Ძ' }(V`.tX`Ş4'H<+x.}W<̚5+6lٯʈlt>m\:=b;߇@ByLǸmdX'%4@9t_4iُ. >(~ }T(dG>y~=iuY+@2{Lw9;w_0o޼`=0O沮' O9&]qԩ$xbiSB$Ttd2)S.rફGL¾ ltϥKldvh`\i\G-H%z*B$aRÖlw? _|1`27N)6HKQ4s΢_tvMobm SAI_.ψ=ˊ絳ӯA,_<e~.9T]'4i}͏BB<黧{1b>堃 ~ވЩg͚x֏UL' \ @;0Ol'Psfjۻt=0H ].{9:5t{{{!Qc˗/S=JpT'?b:G] @J%-@sIa*h ƻ{9#G .`ɒ%~]UxK/ 6l3{gtPlTN~P;nR| #vt*Ş5z t'syKd2裏xQ=s N9mRGgI'ղ;N]LNP;h$۸+eP;鳱˹RbvmL<9Xp_D?-^{]wlDW@e(~ PM4H߈Ğ5rY7@:,(w=;MMMp L:Ӄ;l .; 62?R8 Ĕ/M~P9RP;IĞ-f<3Xl_DK3g 2åK칡ѢGTO<tvv5o;1bU{ofn(fGN}( zP;ĘNh@[LW-;c|'袋+xW+Wֺuѧu.c va=\,L}). @LAlgNs032QS3eHƴˉ.O=O$ܭ:0aBp'w^gΜ7vKw@M4=j. %sŞs];MpLmҔm{O" Nv(=P;ԐN'5ѡv%ŧj4s.LuyL 7zGIMQUy[󨶃3mľrߺ:'? d}<ͳ.F9E*bϵW\6 j>]k.Ş ,Llt9Q ?[AŌ~X&G qGlPP;gv4:^.0pzSbϹ?@\ se+z' oo]2,iP3KĿܶ`@CNP;TQ%27C\(98ЈFܺ^&w9 hXŎu5Ϲ @L&L tsua*Th\238Ľv`@ҩ;!UpNFP TL`ޜh$[޼N&zN&ۺS9 hh:%bǻ].NvMa!v4Lq[@\^d۾sC;P5;Y4e&m'== H?hsi[3.mU b*EL6?_ȴ4L Gڭ˹RFi?[,P)WNv+]Y bzs\͏BzOW@ܥ_ZO/jG֒][ZirnSFsqoJ.gZZoεާSLgrmgmtROm\^.iX*`RYw";cO)_se{o*wǖg}):ӵ]bWl.n@mIU)<+]QKPE)'o}gh4{MXu(g+?3oi)osJsvaG Sdf bǭ*_*:Nlѧ TO67 R9_Rini;`բrS?3iW4&-*j @Dli}_RQӳ=O}mu_ TܥbǮhw@t.џZ8KK8׾?3^^1-ͣ?5P1MR(V) @]"2@#rKB-%\guMng h;Ŏ[@]#2мm4m\{-hjf8KKp]?NO/_sY,v:L*'vH2H#JoY&_ @|vO]J FJ]JFydT~b RO׵yM-;mgrWڔOm9" 4ebǨ-PEOT#zWFHjMU,@|]3|[s˔oJ:w-+Imזl~L.)XA8GH\-vlZ/4A.#\uv9,s].) ]2'| B+b; ʫ.@U{bSɐp]~ͣ~;PcZGdZ~ms|d<0pyY츴Z#P P=E?u\ JsY.Xz.D 'WL.@R|eszI/?/%\۵%2}ws+b˛7v?gsO9 m ?Vv(@6Iz'./=5/Jau;wI]CUZ=*zM:?+-)ͣھ^UQu(7]8чr҆/4!.{2eؓjҳ^)\>粱$j%H+?*ߑqNy_ҔmEYUu4gR^d#hpZ 1O"_hI$sY)w~L @u;XmsߡVѻwsx;?Z:__(L wNe_VIZ1/_ D ߖ>=!6zzb׹yG Gw>(_qA[@Dޙl~{O{GnZ>e1M/V =y)D= rt')B.JJOԿR(וۦ۸5/e vUl~qW .OSޝ7 n5rꪫe3֟:EyR]T۱bawhRH IRSԺR(םۮsoiN=PҪY@s/r3bOJUO. ;3./w<ŋZyl]]C=49rYe .CzNsR"FzY쵢?$OcT ˶mo^k;P}k%g_ƿhqY,T7.8䓃)S3Pc/Z\,yFdwtvv8}{l6"R~>u6P5C]NtyY5IꦽS1 R{J󨩟?T.SxbSTZRxG[bOoz?a/Yﾻ)jbCϻ /O}СCI& ,OEw^0dgnr B'E E862.Ak?a T̷]{)cǎ wG}W 7Տ>SddbA&ͯwH}/S@0M1ƿlrOy睃o=XrAL[oԅo.O$xum[${݇A0J˩.=·?`39'f̘lsp7 94(?@Q]m[d˛7?hl\{@7<>}zb u]3~;woix -So/?(a7e%tX\G:tvvvaРA݇U `  n۞oҙb i.{>:xR7N9{c] @%b [\N2cOqii}%k P7Q_ s+`-+0g|zǃO~f?C岍P_P6?@%͝˨e~[l.7ڞvEӶ0}{N ƿ(_ =uY* 5:ɓy{ ۃf_%._PG .gr+B٦}ms-3*c#k?__ %,+vXꫯ4 Gu?vd-6`uQSׯ4g>N]M3,5H.w={СC7hp3f b2s&@uAEj(`l_Ri?t*g{ϔj/*/ :<a0aB@1 . ?pߔ\P#I.;M-7[b[d/[d5{j//owY$+GV@?TIDAT*# ]*P /7gGXFûz_dzI`b ]:t%;O?%=s{a2@e|]FUly\b={OjyTnzUuaa C.]b9SʢI'd2TI N&vyԣϪkwd)#/e__{X455^{<r 7wJ=# RPܵgN]{O9u*;u\X~wac ^˥b9rd00 O>d曛\2H(P?\HLw?VU&]޳?~yj"6TSr![o@E,Z(8蠃~WFڤOP BRRm[n}Wc+ڭm7?Y**"vշb9˗,PQ+VN;4\آdd;U%-3F)8F9zJeGM}K+kZOgKv؟U~s#U=")/?N ~XF첶&?H?HLB(WlsLKl@bz9EmsFɴ-?~fcD` T.}3co?/׻|= 5 Q 2˷M:M\ߛ;]grnd/e+cDa T=X"kgI}}?{R*Cor7m??Iijb@1E"1Fs؃$2Æ z)X_W0tPˤ$Qpm~“? dBO"bDc tMy PW>l0bQAAd(ϖ7Sw"N_T _$_&=("3f̘_= ^~`2m/9NR$Cx@sm_d )cڶT __|{@رc+Z_/+\>/FACihߗ.4Tc `FK;u>AGG{{KH?@ !(2$_" >%v59chh/q=@\(~b$؝d= :;;hhnsYOF?@b0/bwR}ܹsY7?/0@Dr> s5MD:\>(zT Is؝d~@4ew4ODn@*k a$їQ;e̞=cD>%ZT I0q;əgJlqYKB?@0/8;ɦn,[߿t`xP+* _J"wy]hr762L6OY2DF2?@,0/bwBq+Wkecg}5UDN@ *c8PhߧٳqE.P-_F"nwq 9s|E'?@ /PC-v[#MMM@?+ǔ[. 5F ƿ@1E\ZNgrg08qCPY:_ކHaq[#L&xǖc}T N5ƿL:,Pgy9"}T 5#ƿfghkDPXpE+y.0P:_^,v'34i_渋ȗ0PT_ yT_C5+0PT_ sL8WT~sEd FUƿ+X&O?s/" {^5jۯ6a _Pebw5r衇(*0a9a+?@ */CQ S f͚eÈ|G}E;<=pI 0JFe^F 8ݘA(nш *.D"H$F^3Upø*(,sϩ}RߧU3oU)~*!2D8#zBw^SS;?Ds}Qc@@2D/PDO&ߝb0ydu<Pƨ/4IDRYj;/{+QEC 1_Dd艔:˝bti2 _I1 Ȍ?@Q_'kG1zWq@6?@Zd(-ݺu Fܹ:>r*jE'}vڹQlmMV@ikݹƍπc`?@ F.#*(!'ܹsy{=u| ?@#`Dt艓={zMMM5B=b@bF.#J( DOtԉ?҅^NܹO-O Pl?@#`D .{S~ Pj̘1j>9b@(Py5_.&[DO /PE3DO_. J>:o}QW\qYvQI%?{W;o>3B+P*C\$zb;NXo~͘1[h*DRHˇ~/K,uWy衇ܗ<_55 jOTRcp j}YgE"O>Q5(ڵs+w}]4x{Wz=zP'{ｷw뭷z_} DI艑w~!@o={T5>{w'ww{7|s'tR ].L:}> v*nF\ӦMDs{7t7i$;Lcƌ׫r\555/yߘuxܹjA3~헑劑.[zI/r=ѓ"-;bժUgeĉjowLy˖-v>wI<78˗/O܊Lopݧ[PQ%?֣>KF͚5ۺuJ6 r:tP:7&q]O:ϻ&/]gPx wr)jL\-[Wͣ'DZN+'@~aX]Eja@r|'&ome}QYf׳gO͠mۖ`HC.߰^3(7|s2wqaw{ｽ8o}7vZ_bE6ϋi9s;PRݱcGbI:meҥ*@I)k̘1j[a4ix,b`HC.744ukMXH{qQHW[A엚̙M8իZO.7oZ/y[Hܹsy}v38]<2<~XIr<@I)럯Jm',C UD/VJ.]۷#  oLeΠ\qަM=z濎{'qA9_~g۫fʹ @liYx;PR>|NX|ޮe]k -ZHǀ|*P{~?L Oqr绋G~M65őfz8-[u墋. }F_G@~^nbo/m/J8F"-ׯw P 6r'G}aőڵk> :CR?KcEv]]m#,>x} &#AÐ?1*UmyW#g侎g1ow#w?@ u>*]g #\(_dUDHn)T'@:, a!psQG"oEvPĨTҘ[UEfc?^{]YoPcTX6 WWtG+"DOϝO(PNjA.ѣG!¯`ӧOKvPĨTG?]46?'NtE?@ocl?Zd:SvbԵa=2`w>@8矫eҤIy ܹsőa@/P;bTA?,O>xlr .,[n]M,^]E=rᇻ * g̚5]<6z?]zj@Q)wyG?,_~xl,X^OPsKqJF$ƨ\/_[]MoS믿."'BZ ''@|:7p828#> ȿ6mZPl\J۶mS),˗/wG?@o_"эϺ@s艐R>ڔ9眣mۺ.gr)cU0 ԎExJQ\qjAիho?o" pupZ\/ϙ3]Edz衶w(/HDHˉ'''@8tAq_WP9wQd0|pr@Q)#F裏v]sE?@o}\s=(/ =r' * P.wA)N;Mt][wľ@Q)ꟁh.2awQd@$ƨ//餓NR!(v( D0Gi }Wr݅^^WPڴi. N8b 'F:v_;vg" 7Fx8/q5%U!-<x>Рk]nb6dg]w߅d'AM6uncuY?@ q qE6DOlذW(@'@W^'ξueڵ~zAP$Q;,z87&\pb"-n8>e7]ZXQ410FlMH -Rop_|]<6z=a9s8B 8BT/ .O6CBQc`.lj,zbotT۷oڷoC9] HɷjO J]\zj;a9#s7CuE o "_ iC.\iX>#wV{vҶm[oɒ%*fڵ^Ϟ=vϻ@3gT0 'bl=ӦM<*>nXȈ7b\p\gDOzŶx~ӧOoj h"oj;2|w5>ݏD?+Z:;،7 v2oȈ7b\p\EOy۶mspѣG'̋Vw֜ݴiww'?S.wU;帟(E?ʡyԶe}^|V݉dګcǎjreB?@VB:\pQM$i<_~#<}lj{ M>#>nKyҥ2:նSNĉO?]] {Ӟlꪫ]vE/[N=VpU9Ǻ=QĠ\G}Tm+bs=ד-k~Wcz:tP{g7#w?@Vp? GB%ztϪ}Z,\TFVCU5bý/ܻ['Eov=3~sJ`ҥKq qEn=Q2bw!۷W):h RgȐ!\m?^Ӏ$OʩƏUܹ矻/9rB!.s8(p%-W[lq_gyZ_ry%~6mڨaQĠkڴi~fd.o5v7i=Y2{lw! vskkҚ9{oo>q"3sLo;QĠkܹ ;W_}uW( 3q QEk)z¤媫rdO8nZ{Բ:O~uF\}9(o~2K.cm6﮻*5z-%!O?@^#`.G5NIK߾}y̛7رڿ'@}_N:Im6  G+˪'2-?Qڵk;mvaÆyoP  /Di- 5_Fg}ߨjX]u-]Ի;Lm_?f̘[ZɞwyH'F\_+u]wU-$>|裏&+7߈p QE1ԙ=iboo;0`ץK©Ap ޥ^=É_lܸ]U$6lkw&~zzJJƿe}˾vZG]qc=բ쯖4 ض8 O {cٓO?w{gu7h G^Zj ;u;_x?~|KoEB7"\pQ,8i'4  PaF \/G]PO?T!9^a B7\pTQLL6=Ҷm[oÆ \PD7nڵk؇cPLP/Ja @= (Pekѓ,-:u6oYEi&owW]@V"֢J/Pb(DO4DS[HSB_QJM6liu]wh{Lnx .(DX%Br[Ne &MRYH@Q%@Ď(_l=ҡCoÆ P{۷WY@@Q1J/'M7c F?@1E9!w'_Zڴi}\ŋ'% =& *?@LbBrt r駻@N>du\6DPr@ QdIks@x uq&}gc=NB4k@8@Q-zl=iU9o۶mԔ[z|:>Bb}Pn(B3h ck2fСުUch5kxÆ S-*sPy"~lR.22i~?cCT_2cofTc0P{ܹg9eo RMgIТAɕQsmb_r( C+9;}peL6miӦ2l wn&@.=5?KJEo_Mvn dʬj}8Y֜y޺uhÆ ިQ|1 Ru7Y-ɡAʸkY6S r"Ve5 ѣ7gٹҭ[75r@%ˢ,6NxP rPJMP #uꪫm۶;coW&gA*4+DD?M:P d0k=Po{r/9ftlMɡ%AJѯŏ@l/l( ?L,`)@6mrPcnݚO6m1/*.&>/&[FZ~=Er( FVipx{KF̚޽{{o;x9>kziwz? &Zr?(X?~m~xP8_J_  `s%xk׮uPV^;V̓XsJz۾}~*m6ڵkț&Zg~-O?SUqcٽUkc z"*m;D9o߾ /w½m¯I gIj"PUjwL}#Fx}> 3o<NPysPm~%=ߏ-&V$PSggwZFH@o<.`+~`}ez߳L5(jd}?[hj'CTV/1&Eyeȑ|T z+ _/j E-+O ,9@!\I/y={}A[=avPng~ɡQ"Wr(*C[dCysayO=!&vϜ9;տOY`ri.?cCO eO,yˤ]hՈN&lwM2[a_{G}cr4P:I-~?/i]]*ON1!oser(*E[VWRBشi;쳽7xkjjr߳P6^zWWWnC)џ~VtOZ?'o׈l7 V_6 og}xo{l2K|ϭk& V# 5ÓCkOi&|fo5{ǓL>FѪ 2{G+Wmb ~YD[|>& ?ܛZSOQ}dP5(SGs1$>s=}bG~+R>5IjI;D.dזѵD"uɡjo(dϤM}#)Jg_xoƍaۼysy 7tS|arwU7lcjof?5sZE1_ξi_R}щ7Ù3gz֭s/+fFڿE_MN7i/Zuџ~.KE ")oKw?yEv8P@7ED{_|7m4w6lྦྷ{7uT.>n^2*j]GENyU O`FEɡjoTLlik/oȑ7͘1{7%Kx۷ow߃#gim_O@wWx'NL?u{Oco֡e4CdߤHqd4Ώ<\{PO|iloܕ iw^7ʒ})&I7/RX-d3`mM^9 oFPD;W~Nͱɡ{R(}zF8ZHv29Oo@6Di49P.?Ѳs~Vchhnc̡Pv N.fGw&#L%LELr O쉅D;p1Iml%Z&K7\ 7Z+&@8(7MI(dJ(&6~쭢'gt1d4{B>D>|7jzC>}gG?M2ARK{&Q6vurh(_@MF(ͷ[*ʹc_}oӒCQƨL>oÿP/ '&Ln6;&kDƕk?5r~@~>Q J%/XA P:/3;Yo'&LIm[dWOv].ka5Ҽ -MJ>S~^͉/[|"ͷm0Y!?H࣓CԈRszrh,9"],(Ϛ|l=WLėIv'C| ɡ@9ͻP8 PL>݄d@1 +[_ݢ0?MMZ\(zI9gIMnc;M[[ 3*9Hsbz Լo=OmҮe4ja$f(~>@2MMڴ].zؼ:04&z:9@v ({aO0?+Lq)c8sO@@ ݀M1ɡ@ Mwؼ:&E?M2@ncP7$ 3)95^y ^&D?ӓCT {aѵ6{0?L:$z[a~.zΤߓCTsE969P,nl3909(l.1u`ygIϖ*Eݕ (#nglr(M;~f=6%m/D7a~pvʹA@CMv?~~ , "E7a~֘Hrrdh E?M$(SME~.J˙Ԝ 췢R3ySɮ-6%]0?"PE'RYcAf~ɡmlɡġ.uj-sƿPղ2P>=lFo皟w;Ŕncu=^ٙ0u5Ztgc"jw6ܒQ@|ncu{L] p `@uv^ ܤsh  D=3RE?=^0 vOP 2 E?SRTg9gwZFWmlvvσW~ 0z3, 319bfd 0Y-z y=Gqb n49d4ߚ9|b{4i L^6ybmmA%c 3995EoA@ +$ye$*&L2~\?mc<:{bNMzۅD~VtO-nC<ۛ`sPwoH|cߘ-(gLoǞ ߵe4jQ)/׉ގRqܹɡ(ۃ9(?^ ' M1SuTjncΗw:]Qw"9(پj/^e7?GO~QuݧNWCf.@ys@ Sӿ@7 82ä\_P[\N~.ME +研q@c2zU<}E㠜/ϓyp)f쭣Xw6{A)^׷;6_p'Pla; ZGEyUfl߷q@U2P^oPHa"Q~4 k%?eySrϋg$wyJn)|hSqP|(.UI34M3 T v2( 祟m¯ԋEߠ/w;<gLudeɡ#Luz<6RC+ =[/f@ű'N.K{tNC^$z;~maRɻoFvor41qe,hP*ncu[Ώeic(}F}>B3?U8/]p+-/俥yI{er6qd ?' S}lٻCQ {ݯA_2࿇e4Q)#i>ai/͓P{ػlYfOݪϏP>)1u\ߜP&.et2i+"~~ceg-_o[Jyn8F969,GI]F93!Ϳ y7S%| ԒSDCRUP=o>VMz_C3ePJ3稟kvfg4(Kia_F8ϛ+u&'LbwtGCPsi?rW@m])q?35i*]pw`TY⒔N**Ax" ".HFQ䪈 (A$L"9( $H$9`Yv睚*qys쩪>UuޣJw)(; 'rFMwi:bF3@ЧE= stY*gIp#5׻L O]̕`PeXyHЦ*H]gT[.{٦scO *X,QZbW.tpay]m [3? v;aVZAÇDMQžr nITMS.cjcaÖw'uIW@ֺ//ʅ@8IAwrdF2 nTa4uapJ9Q֗|\//H!i2)# "|Rr%.7<2e`)k0nY)2D.AYs5:t2 RbXnyVǺV&iOz.Gh:}Wjczr52ih)T2E;U/@#H A<.qT.?zr1Q9<ǓaDt!J} d~hGMQB=:ES.5 Ȱj/j-]K\;/ <%пR-H>@q뿧a"/3L#?wuIVv4:hdpt#ɽhkzd\%5ʱƺk7?H;?ą&iDAN;Yg-QĜq0"K{Oby#Ȁ].qzOY&-} HbqdX._x\?/‰4NT&A i B0\?ؽB{%F[m.*EEB$x<{-.oX;.[H#TnW㍀rҘ>sd } EBeժ ̙^MQ%}$&=z.EW~2;:uu,_ <;pL|{:a1*|a<4u1m5EROEKN+l[  $4T%y-v;㍀)f>yZjÝFI˹b_C0 #5<_~:C+u;pk;.;94< { Qz6w ?%RX$}cq֗Ot*j 8YgX)$xx[<}[CKR}Iv4%tQ&\TY֟^>7 ߁wF ʚ| 6~\?R8_b~Mm\|i.]N{\wy1\`OT*[B*ң=}eй]⿗J$+bѧ*GR"9Wk(@*&66{ |{$ S?3Rٴkt{"=oSmdBԭ̓C:t]vvsЧks_H$j Л-ϱ\ ؤӧHPZV}Uv4:( dYc_2[Y=,sžRadMjcf\~ڔF>.k_y{) ӴT7}۝~_szuRӆil-fKE?O%nswnKWv43e+H0϶sKwظ3v sžRadIgUdRQnx^^71=4@FujvLE=^{+tPm]l9DX.YQZ/;@v4z:bwFM;*qL6;_%g4 s9Sˤw5(ݫb[1 W7$} $_wϲTܾeeIdbK od 0?5X G-{<[Q3es-=|J5|>,G+O{?r2VnRu}]v472L/]w<̣.ˎL =.O= Ӗr}GV@ӧ {/ЩVuK{v%= svRnR~dF*}J_L]oGs[q=sVԴ#1 6g'yntn!;po]¥2r hqءN,Y+dk$XO㲻\>i-\>ˆ.뻬벦$ J.KVWDŽIJ"g%lZ*xd%v;m`x;jqhj7&m\~5\0s>6Ejyw%_8[8?%6 ;p)@*r=y\3 :ks.tO$KražWatHG6i?R6\ %*xd}Ov47ĥbaf䣦`ƪVm율i gkG`x5jgh^S_ %&-HD쎼lޑCmY@E_{^-O)\|e*?r9&X$5zHᥒuhb%|C.՟h? 4N-Ɩm݆z/.q]t 7IPcn_r'u~[-;?p݉̀/3-mGIӝb_G$Gbс0}e|oDM;sc0Qm,(lא«}{k5/5ԚV-λ|o#*=0W7౻P{f:QSdAs-FI_G$\o_·QԴ#0 ժ5m_wի+?x9Vn_Km)̕I+λtz/#K{2L~0'-ۍl;MZ*oIsJ.KHNF@lއe`iY:L._x̿^9[Ԍ$?k)?WhCE%v%;u;Gˣ\`Nľr]f}\5E铬g[* ,ݎx# }M0FMfr7(]J4W$:_~]VmlݨiTz>YSz6OV U;0K&_V)iٵ|@9RA{3GId\! {42c}6Zʥ?X$Q 7@|]w?_QӶ0VYhZ?%vq C m<_% %p*@3iil.ށcU{^*$ґ:ʅ`}_,t*j;ϸT )[Yk)`D+=o.+~#f`}LY@q%:{;.g"D.?k3.P%}*r}; Y(k]@G{@q:ʥ|K㣦h>xNHY=/"*wF@[} ׁvV~`QgphJSZ$!sZib0T˒oPr܎;E GO{^*F_CtD<⣭uˉ夑eATG'ќkx%HZbJep=gէHUA-' Oi*j,!?u '])};{^.{,} g}?u@m` shYfLuH$'v;⍀Pix[.DMougrx%]4HP^jc'DM<_ Nf']>/IN8:eǑeҠs ?/5TJsߋxM;#4_OOҀh~ot/}!?}+D0 @V{V*DiH+S~zT;Xz*1NP6m:i[ډn@vkMt _Ѿb?r20O)I*_5t]xm} S⿟-m)]:bߗ0Zmlۨ).TJwT@t s^?9NA}0LvON\:ïatmè)ڔΓr2i?X$Q7ݎF@:_l3eݨi1 @{VkΑƔ֛@mKWJ6攨)ځ1 J{+lz Б{P_.Z>i`DM(vY(v[%(V*n%Hpǭ9,j6V]ߌ,63-,bA Щtʄ0Ip6 }cudFhkNt2H#= C6Tp~`t +op:^ }E}uK /9>E2ҮғJFڷ]wNs4Z>Je(\ e}-,nGx#Tvі07>q.@nh$KPg/ža6֦r1J:))Oa=MSw%7.Ů7̟%<Ŀ\Fi7^\&o꣭ =(ɢ3OH ;#㍀#}$V2jI\fdFjn\fNSQSbj.;I-F[%{S. WI%¼r'xtđEy`K)Gi7[5j%ZA<.o}-,;nGsD0vYnus`QF+8dc}Xee::U51ʑ4Hӄ§r,@ּ$Ia>X :߾\tZRƽW*߉GKޮ?霤YO7gf](f0;Ok)`D]v4̓ V%9wes`Q`m݌Ӧ VT33Y, ٔ-} \jc.1nP!L) 4m\* 擒 sb>pyX&Kʃh߉m*;Q.iO_b_C/,}:ߎfx#VpyRl iN94$߫GIUb_C.ƪU{T66> ,C'*r=7(n uN+p|_bOcfKo.RɊvdV("ѓB5TJRz\v4{x-]7afB= 0LZ.J% ?wX5O_FכMw|.)ܐ|﷢A湮OZv̠rd@z ';J:%8yK xsR/K^Jq}QSt~?JeeӠ|^*_Lb}Ol >\fdS=i@k(vVm쨨)|‘)̔lkz ;\):5\O՚$]kIQSt~˗Fi/v {^v40tʅJ7hyeF[z.@3 @2jd+5J;V6WXEn_kzjbw._x3@}NMS.[W5r!SAz>O/S'KPr<=Y]p-J5$SYe漨) )Fi[nZu{ yx#%)32i9Wk(v.{Pmkܱt._x^s/|&5ͤX=_+*-AOo{Fm ,%wTtFvkI$ohv7PbO<_gx`Ԝ+5J-o'Q3pEk2Oz\E.*@u~!WJWp@K8V X.[FMQ})kFi<%v_7Kv4(r}(>ehk@=iK+5J;W6v~t {k0{.ڪp@ dS:MwRj m$,|ZR,(Z2۪5rk3@E+K5J0P gxerP*6\ژȫ7V\\w`^-N7{ HAWkrbOhktEw7/ ջԓ~IKoGutq-!0FMnALjPmlrkIwFܔ]]ś!O“БN;沑4ybOqy_(iߝJyw^r|d ]䗖)I^bRy.pkDauxr.__{ށ5T~c{byxsRNZd!-h ;=@Y*EH粆oyF[NpVmظ) өͳۯ_;cwaԤU'aaEM>&z|H^)=^Y+.xn`=gRFmo[bTEM@cu^jcI4m\rk5;_ m6=ەf#k^t m[b\)4>g'aaqYq5P~>.<-KOK{l;>)KFƜ\[bTQSСn ժ5g67uHaQw6$O{[v[j@r};_)|f˧@ʹ bSi&>?б%T8n9X;ћ$_ye1|jc gcJ\O| y;%?} ks=GK ,3pAOW~bO$j m[~wf* ymPW0FM@bJ7SmZ;?0ÿ@^+_ripoM|/,8Rr_i w IDATҴZV? ewm Ͳ.׋~5*ZP۶T Hb惱vfG}+ps}Gjc{{r%g&]=u0MЕ/QWNA4oĞye)0.z\]K2O|VJIlR9 \ !Fp~bsfT 7Ojc\n/<_B ˮEV { 7۝u^x@jS'%0FMĬ'AIV6%o-.W*G $DJfX;c7!},.<=@a96*ֹj1Tlb ]& 1eG[vp)7̍tu\f= sv@m#ih(M-9+j C1HO;c[}P3'@/QS&n:4bO0!CFRqؾf -5$-Ꞔ~@ v5HJ.ωaf NV-Ɩm H.O= sKw@*5/H.0GDM@1ľ0ZmQS@RĞN@J$?j7S0\6 c89ժ5$eO'`|9j E_5OH.awYj5*,Tĭؓ0EMbF<tySl ˨)(qF5$!2CIX]6KCFp}3_QSA V_Sj EXl\oeVg(ĩZtuabۆ)[l?T M|[^* E0@ `*!NEq'N$Kgv}bx#maI{0?Xj 7mj`i;x>/䩞̔`WK[K@y?@ۘ>F=' { a6%|I TyeEn5h+瓌>cx5{T|Zyޱ6KOb}RyI"=Rش) ('QI']=-koLryElO"o @@o\)l-@oFMؓfVe@+[El sxȆ]J.ω=sKhk@]v{լN,XClX;oM.?7# hwCb¼5k_'[iFO,ɋa֎Z}c? `~fxQS(o19u4ˉ "Ȟ0}vG)".5*s,'qέZ>fYbÜ5IVwsI \W$\ԒADS3]ueE.p]>,7p~42r9eiea&6뿐`P덌޼5KHP]ཻ;\yYq\`n݆>EY V5Vuanښ ~r˃.o=AhFt%t˗]6tY\T_YrvA|˷\>鲤IE:l χY1@{IpC$}vo_(Uik׿A%(EovGd|7zbQSYFI0XZ%nv9e{U\&57ZHir"ZaՈ -K|'$bD/|(u[oYfH+b34kW+=?xBh1l(":o- Jm.8qѓ]7et-ybcͧ%]r\ҟx7m:NTI] uGB3[Z*'`|E]䲏ʒ>MD9C< LK+APov>rCbKޝekiMt,'TtP D+Ƴg@+u9L@)WTei~R%/HO340H@:W`'EoK^ _mڢe?ϓyh_zm [\^ʻLZ<{0t\):,O ۮ\$t~0Z6VсYbǗ-$M;:+ ejoG,&kF]6|:.# %⋛mZ8z.Hl6:7g`x+4e]syP~T VPdswwqK/=&L0Z8!Tv7PZO$F1l5@ic$K?xO-\wmwbP(^so#_zY-*b…_x>X曋W^ue .(z#8'Ol^Os䲂?-we sbћvpG<' @שsjŮ+,ŭڪO<~⥗^Z1cF.>_8o9]S׭m6uI9OjAZDw/oaM.Ӥ'E˲.[i?ӦM+R`s=7<<00P<ꨣ[o̕2>:簿]wY:̉7 6t9-mb]|C~ӧ{o6nܹG}t5viïQo_ yXhO$s04Zy=XOm3t œN:}eDu^bO< wn{#FP-={FXG.%)So/x]wo5Z>Z~}ߣO]`E F^߸#v3L8qT>K/o^+^wuӛ}J(ZF+0 drU4}\{`>r>S꫋f1ynP.͡C>GlC b5ZkU<{oޘX'ZF^s5@v9ͥGFm$ p:z#bVK_~9sגP/\<r}`(e/͓F0+B._BB"ۭ:]c̛.',#0vZ߿h7}b)cFmT<3x̞={xO|G岭6Fo.uѧ)2KAvx㍋\rI7^}gQ\yg2<csx#b+KƔ>x3ҥ%<@y#L@3<,vFKp\{`]wtn3f0gZ͟??&hы9TDsO~]ﾻ;p Ew@m%v9\qy[쾣,Λ7?$B5:OpB\}p3t8F=h9{'Of]wU`>:wj=PQb|S\Ϩ9'N.//|ԋν8ًV}jShqm1߅:rKȪߋY% +.Yz饋ӦM+.Z?AZpa/..Pccapl32[ K>jӧ]!b0an} >2_lB.Yeۇkʞ{9\W_oY.`<M3v9t-{rQGΝ_kAzW쳏}B >Ы Va .}jV]u_Cx^=1Ol*P.\&LqH`G{ؿ7.t߷\vu @u[ArL2xVUW_=r{Zui5gϭ:~>\5GydqΜ9! :ٳַw%Q$cUu/`[Mݶ}-x[\6C}iUex|wjޔ0Idb.3V^.}bÅskKw 7'Nh?5DH듸;-!:;}MHk*ľUŸb+j |yw<㲡-e2* {VyboNﾻ՘s%h/y =Yb֢$vol ž$ h,{\1k_U= 6|jk̏ ;tιbs+bnf{g@=.\Xy_; 9Vr9 o#$X_Q7[:ei$%]{0]1w"s)~_4I0Wߏ]'Zf.3ݲ8qb';K/V~ T] .ɦGZk[lp~.Ru]{vM6٤8yeHpJj{2w6(2#c`:byPW\_Jo6g58;Hm}ʛ.jCWݲYwuO<43V.s=|Rъ:mnVw[<3\sMo/>#ŗ_~o:t]N]Vm6f 6`/h#%Lt .FgEb輋zP]6z0c \Hyg5(?ۇ.; V~ݲz뭋3gTm|/DP/A%}7t!2}b8mf\~/`lC"@]$'C@ZG~-+'7o^q=0*yem-|PQxWG{w (88i$6 ]!Ay%\2{.TO{^6+B',a' ,X>8,ZUbm|k_+gN(Ҽ3# 9, , ,:\ # \ €Hs)Ǡ* !}4444_ՃKY]=y++"+:#3"G*$Ot]<ί oIbŊ#K+D'4hPd[<2} Up^jDtU&j4~\̦U0 xnduMWC6ٷo_^6;?'ES;H;,Oɩ:={X Uv`|FrJ*EAa+--M(` 7~|aATΧ$kx LB`dO?-m)^kag->Tݺu,Ybeee?~k׮ސ5k4'𬙝$T\9%6mڴ)?<کL`$p~Ni '}2H[vΒ#1o澸zj"`ocI;ZNGE)%-jm۶MO>:||?/߮h عDjKt_FK:JxFZCoĜ *XӦMΝ;vMH0~*xԩ:P%e%@drK0kwf~x8s; 34#*"^0~M6mK._F6ܲeKѾ䠝Zyd9z`<մiSQO / KHQ$cNJ6%%0A/}XgWdՆiTtYf͚GJ] l$~Sڷoo[N~k֬Qo ;$Sdmx9$0=#z>٥ L>|cfREDI[mJ,i߿_0tޣEJvl1uƍ.~XWEpGv*@ ^bmBkѢhQ'v"ه9 OJ$6=7|~–-["m\mQҁ©$ۼqL6mLޫcN!7`X;Fb+^fZjGroC(U#ݫ '[thQi2"=F ˗[իWc޵SBO$:S۳gUH\c> *og ?@6/uJƍ?JRk`g6)iiiք "+>AXoUhQQ1;@T!OUrc:O?T(NIxIVvaH;t A 'sv;#\%ٶ=eȐ!ӧծ!s)kРAc;O)L;אjdu| zF}!J&PXVRJ֙3gԯpP-KV*Kx`^e 6) 6mۦv[Z 4!,5@WgyFS+WX[}"J!(އo/X^fǎ7@J-jpn;Qrۭږ ^j1TKB%~h޼yd N7{)^c@6 Rf͚%EFfN6gZliٳG*8`s=xE;] El"9IKKۧRʕ+E7 'wNK;cy;s쬳}3^ 쬵3svz&vw"ݺuSRR=Dp &\xm7ֵk.)Ļ[_ Jr@͂ Ա3@:t#QO@|pʝpg 吝ET܋'vO"ʕ Vd2eʈ~v~JS|m6ԭ[ڹs5F1S u3.cfEz!u .]dիWO6TJJ쓼~^Aekm4 hfk ZJ(ARrWVQjy駱/xZmGN ^KX *XX m߾*T3.G~iTڏžvD?R՝C=Zzȑ#Eqe;5 x=$iԔ-[Zn <J.-ڕn$~/>+vF o)w9q /oOA6SRC!;I5kFV);;۪^7.)$SC;IϨiٲuI VESv@@ՁH߾}q1܀[Dqɧ_V{;s!O},;mW'_7_p׋~% y~o'dcg+WX?hgrߠ:`)Qu)uL oF(RO"{!/G;% )UլY3W^ /`͙3Zjw^jw>6W_}e͞=7n\\J,)ӧJ` nj[MӮ];џ\2!\mhc=|Ɂs=y֭[> |EtdOH&FY>5m4kɓ'ծ|n<=uT_~VÆ #eP˕lv@pմsd. v{%k@Ÿ3rY"''0`hyomI>Hzz:(;v~咋vTN;?lqM"EmZ&LL^tIv [oe#Z3$۬ȨQ16lW.G+Ajs o/hy'@!97o: 8P-Bfg%ٞ㒴4k׮֬YRIk׮EȰ:w %9cga"vl/^:{} V%D҄d]vΑlo8qڌjɢ[$]$",իW-Ĉ|> kRhB&~֭k=ڵk˗/]*Sk֬ƌcթSG|^qi;HIOA % ~rj;s U z7E{#⬐$"+WTǵO\\2{Bm Olr?'_!F}LC2JMTV-U~@drܹsզ (g6K#OOyx *վe; Xsdwj֬IڵkWdիϷ9bA; ?]p}\*m5  b]z=([XAr)n:u, 믋q^RP!Gի#{BlݺDr)矫cVNj??Jڙ`*v9<['OT=ͳ>`r,Am$6HJ/@X*TO^.mH{!4wjvD;v~A1?ϒ\:RfM,SNy|YM$۟p{5jTmx"xĈ^E;M $ٮDO6cHS璮]a;l;r-ֹs& `[=JI#suP)2w\u K}% 1~jg _nǎS8'N_ܕF~B[CM9RHTH,hѢjAhS\9ѣjs#GXeʔ>J"su@Hzzu%u ?~Td{x:pڴP|amV9Fq{Qۑߤ3f.~&C mj3[r%o$"&LPǧ`;v}QSv⣐vH5O]rJ9CH[.e\Ӈr@^&lC"x* _|S]A'r2Uۋ6W @(-^X(ggIÇcSH˗蒎Pp|$ۗ*Uʚ={6O\Vɒ%E;!"w|s䤶G:u6QOnTi&ɶ͈#ԦjÆ  Jf 1 k=ʕ+^ Yd=zXgΜQ0\fff,벓rW"#6#jFEȧN$ۈ6͛7._6=PɱZl)Cw,hCr(@r7NIM٩@y*TRꫯf )\hsr/>"^ᛤf)eˊ~bUN&6"mɓjH ǏJ.-KةH GGxw @rSs$\m۶}S]:^(PQ~l٢6SM6i`0}=D}:tHm~钮 vرcզF-G<@מQd|6|75e+@L 7\DΟ?_kT1ɶHVԦIS^RpdiԨK.Yz'.9a`KrHz'$O*THQM'j9@DMѢEŋM KZŊC-A*M1c z-?5>5d)\g47Ⓑ R^ ;Y$+SNjܵsdf͚YGU$'4i"ڕ6E&DN867HǏɶMFFڼ%-RZkDﾽrݑ*UR-mZ^H\!ffСX f;$ۂ#wǔ1+ /ɮcMC-nںvڴ}% eM"9Ht1ѶmDYdYYYt&'~*ɶnkS!@,\7%H1{e1aPvmѶ53A*WD<իWP|ل D{aTd]l޼YmJhӦM- K.2d?O. eErPȒ%K֭['rcp1 `ԨQmkA}R5fRf̘!ڥ'$ّbŊfY!o/^\gM ;IֹH"EB;@2=E%M R/ŤExo>,7 +Ѷ5ɶT?$B,ZHmbI73Ғ Uֳ#={T0f޽hϚFfIֹțo6ɓErZ;B/#7VǕk/A\L0=Z *$ڷ&8t!{q .l}gjH˗{v=$ m$ؑsHBXedd 6$[Zj֥K1|Uzuѿ\ЛCr ȑ#q1ʕ+'scp1 ¢Yf}k8ArHmxwժUj^7--M(ln"7ٳGm2F˜Y?'~pM駟BɁ#K.UǔF8~(\L3fhߚ'HdmxM6M P6l$Y;5 L֚d:RD ڵkjs1ƬfG=§-zi޼l w.K"J$"GUǔFr#.AX2j8.߰+ggɺ׆+LyHUqMnD`1$ԑN:HBuAiMFF,vZ@\R3#{I\:4رcEybũSDvIe*ig3:׆U/զhTy{$0'$ӑ7xCm"F˜nҤIMk LdhBm.Z%'$[GQċiW^vi͞=z駭Ν;[׏ WX/|󲭥Kj֬iozƍT'x)RJYjղڴicך Y"ׯW _WQK#ӧOWǑzjqӈlkٲe?Ho~“3gδN<]޽ۚ0aմiSQQF/l8p@}ի4JFIֵk,Y6,ZH|X} cq_U2aP5s]w~ j#k֬Qǐil /yJB}x'4ʕ+ŋnMk"r}yxg_]]aOuyz {0'%G!0E uHj&Xzc֯Z.Gڷoċiѣ} :vu-sHf̙IK3;Ad[m7nl]pAm27Dj\`DOԦX,8qB.ӧOwС9?|rǹdGhd|G^)_6Hk+VP)@rWZUKLXlc=6 ?Q78#&-'RR%qyfy;xz(.^8ON{D ?53XjH dA?&o̚-СC#7M^-Zz5n'&Ix9zդI>n whD/n%0Q;WH֧/RO*կ__ ةG$I֓#AX`̚1+C=. ܤwN۶mcǎO/_^-\\oZ_%YԮ][m#ߵ&A#ʕSNJF 4^N}?~iZ;W}?L2E=DݻW;Z֮]xBnݺˆ_T˦;LRη$R/ sHe<S_Sn`Hc\zݓ!C"OΝ;cZtz0a(& LS5u[o6 ѴiDԄrEc5#9s;TNJFI4W& 3VbE)R:{z=snyꩧԗM,Pa"=Nz$I֡6sU@J9sQ$AP%Y?,\Pncaz coA7N[xij̟?_C9@ g`Μ9F$xC+%<.oOx\8x[V-q\cټhz)->pV˦ISN6:ڵROtIpFGV^V0fus̚ MF^NzqjР[r(&f#ztK.js^A^$hǚ`GHy'qQy1}Ҽy.Rl]:~8[D[~x_s?d_ղi;dtM ҥKxɗr;vPXJ~Y\"Wx+(SW(Ne֭l!0ɿC,VCaj7i;GƏ̋i,wߩ/O#Gx~O>Q_{$?VdI޺9R}ڷo/ʦIK&YwS5 }DId;B^9zZ˜Uk̚ ^xA=L͚5K[߯<:$ʠA &YYYYjs4LCX;ww,/zΑӧD$bO6V\Y.sի8]xt钵o߾H,[Ȱ&Ly/]Z5+--ڸq$ŽޫH{eӤAЕsd݉^G% Y $ől1cX'yˏ=Lo.-VR_h< A^̑J57i0 agF 9sdѢE(ɺ˾e_~[n8]xr'rÂhW˨Kڵ՗ilRhmjq Pd}8RBj1cX'yR/Uʕ+'ʡɯ LЎd9K͚30I@C`/HQ&KŴ&MХo߾K}uLъ+Dt?€VV˦X [JD:vV?DѩS'я\1A2T#YԩSGVa.cX&Icy4nX.Y(&7`*ɺs$K&!.ў5y8IoQq1V}3k,q>}K=p͘1CKAu7GU8tG9E$ j4cYݓ1k,wС8]^z%W~}QM CI֝#|c0 a7eў5O`$vرC%6n(/Ν;“KX/ϧ;eΜ9\n`*b;%2i$0QKI#S=HӦM*5Ƭ=feӃ>(A+<>| A"Yo"vR0 a;οo$u޽[%222u' n*0L{M JDxo/Udgg[+V%?Hց#-[ThK5 /O^zsW_xwy(&#$CT;3?Rcxoa$9sd(ɸ6tPq|]Vwjի՗)&,Y"ʥL)jgɺYlZŋ~3$YYK5 u֩/OG}T.&N{wv Yo }(&/Acu#ү_? {߹˒&VM#uUh'b89ԩ#ʡI5BD._V=P +T$0§$s^Zi'NCV3P@% o(&_I֍?^ 3ƬI~ƬN+ APC_Z`oiM`IYG(~_L;{8vR|ydeeeB ֽk=֋/h;m?Ckg˭+WZk֬6l`mٲ%|w}g޽ڷou!رc֪Uı 1cƈri2 nsd8ҡC ڶm+&WT%H2$?sG+V0fO3fpr)RDC_pH>}j{E? #L!9sd̙(~_Lp8[=[nmDwՓ]r{I2ezZbu9q_H0ܿQ.M$X"vZ "+($NpcLNNZ}˜5>Ϙ㾫Aц`G2eZ`&MX #!9sW^QDŽFbիWűOق D … vA7&;u$ʥ /SQ/w5 A<^qNQD9M3wԩSj c<.A~ ȶ3Gf^H;vX3f̰|IUV-ӭ… GD۵kg 6,޽{C)>LcM!0$s1Bi,--M_^7.^htMODFITn֬(&'H{I։ŋ?.o&&qAUuѣGժ7/ʥKѢE՗/ԅ+K^QRRK*W [U?(x,3<9#cB$bQ_5M&-SNU6\zuQ.M$$đ%KZ.]RVRDCDYMvdƍj c֭['ʠ r 5~M☺Di4wGed:A&Y$?HH{Y֭S_t/^\SU^$?gGׯV0fMLvڢ 4$$ZMpLqL]ƍk&N(-[ʕ[n%WŊok׮7"RA`Α>P#"?&^uFp *$ʩ˄ ԗ'Ծ}9D,Z&M$$Ñ `$'#<"U_&9;㭰5y0/{'c2hR V/G+&y5*+Wvcw{~"۶^O㭪Ux֭[,$k֬e+nQsL4I#ؽ+C7/X>ܩS'Q&M$C=u!b Zd<-ϩCOiv.ዷa1k`_̶S \E'N `I=.C.\`UPA%|lիWEYŊǍ޽{Y?H<7# $9sgϞɺop w|QL-[>S P.]ZC>0d]8._V+L=^ IoH~FXa̚<իk N3Gx? 汆zL] `=3sڶmk;vL=tmذa<#Hy$~ L0:w,Yw :k%xØU/c0AuUo,&c=t=ܗ8*t"W(-wq?hj׮-ʨo*#FRDŽFoEYrE6x`>nӧߡۋ_~)3>|X=1Zh!ʣIsd]82gJr.&b SLgdds䤝4x)j'޽{2Ƭz^& f5H=duH֙#A ^xA=Ly\Y*/,4DZ>M9KhϞ=,nٶm;R.ę6mzu˒>R_'CL=[bz",[L;ԭ[7jժK 'ue $AѣjeLL:tHKࠏ=f.L 䦞& :s;PXAA,x+0ݲj*垥zP˧I]#G_VDžw Q'S+ZxDR$|>?|Xn)_u;e>޻رc=#MDMN'ږ-[DY4d~B. Ӓy~`8eլYS& i*ؑUeY}X&0\0d d9ҪU+ HX}o,^X}g^ Hٰa:. XUTIȒļL_ŊEz.YYY^/+Vx+Q8[\jٲ8;e ӥgϞ;/(&_$"uȘ1c*5c=&w=N-a9r8oM#n$?cGjժVq0fX&0\0ժUIg kJi۶Z c *eK=KǛs:GAujY#D͛7+/e|5pDHOOǏ!C3<#-P~%  $yc?Ǘ^zI.TL݂K.,^s/*^8^^ \8|pLqx•"?]@۷oZmڴQyYQ-?RJrhrd=sId'ԲL0Mwz.Fd1#?[Vq0fnjxYY,ο?D&qMaX?'> q20_^XfLH)VwZ Ţ%ٳgVyzgqbI"En޽{dy'xׯյkdhҥkbIٲe#K)/ekx]ve.#?zwDU-< Oٳ碥Gݻ`ǏWSy5;$C$‘ڵkUjpj 0I.5BO I~Ǝ=Z*`=2 1b8oM':,_|AqRA%gv9N%k,M~.1@+)S?oّ'S3NV敛nɪW^L>6m8oMv$4uȀ*5o!wc0Z6q4g-ܢVq0fxYcxpRykҟ n#YoZa /O^zsХ RAӢE Q>M(ߒ9/cC#)]{1eddļDr"{BuDR?ß-EhT_ ?5&!H-$‘UjnݺLMϝ;W&!Xȑ#jucIĘ5L9>Ad9ҴiS +~=&MiR(/9Kzk r1}IB˱'i&_'Tz\3j۸ VN6ɺpS\r|7k׮]5h' ^9MsvdjucV$j&g̙59Ei'Yw4lPm n{DP?h4h ʧɿ:'NC#ū… 7._lq=/;׮]RBܹo {i֯_/^k?;?'[MuzZFpj:e0Uۿ!$?cGx0ՙDYcxptI&3 LPd9% Cԗ'RASvmQ>M00O#9sd[nEx\L̙3ĉRJwnk͚5)$ŋc&aǎ7oEcŒ 6l8?MV$CGuHOE`8m5jH&Xq!IKKLTƬYcxpOrTY&B\  `oP?h*V(ʧI%,"9s+O?u\mxIcǎ.0@_D(Yx{þ;-ON0!ra@=XK=:tqAı=nDڵk^HJ cHօ# RX|Z>5N-a߿8MFӯ\#9;rJ1?bxp츝 m| YXq8RAR;Gx0x9uhaV>}[e˖Wվ}{k[oy ~.\h3޽u[*T/㠜tVjլ[o54,OΛ7ڲe60w}0`բE J*V"E~lkt:uDş޽{CO<m͛7LN]R?k>/sEC$ ySB  GbwX[jqJxQpܹs仁3.V؏;׿N<{S&ѣG#SytZȹuֵv_xq8}Z S^x!2QW<ӻw/S/.\,qI7Fue0NskM&x% s*$X|.M`m$Б Lzdl|K`$xs$O% "ɺpĴ}L'1 WzŪԼz^ Ŋ[Gq^؎N#}U W^j=iVGGLNLzzFr￯gO>蛚'QIև#I<^k1{eW^]ۯ>a\7xC=Ft1bqڵE4iHoϐ%ywH/FnrS&# L{ܫȒ%K&a$L3,e=!9sEX|=.a; Y:GtVm8!=:t^y~guMС(& ⍗U?gdpk_i^'YL;EԄ !Y<j0&ME4m`l*Ɂ#<:^lRIM)L,SI։#DIL~ıoڴid/QOӾˑ߯_H󸴥6#7nK6lh;q'NHӧլY3{Z6lOƍſbԩSE4BOE٣V]2DH֥#w, `&@SAҶm[Q6M#=GJ(a]tI3@ݻWG JNO 4K2~xQ>]J,)^-YYYi䉟@UKzeXw?_[cƌ/.W&M.\`UXQW^"ufff._l_4hPIJ*EIct1mxҥ , HJFEQF _tf͚j0&M7,ʦI]%9Yd:f}Dվ5;BLyi&zeQ˧ O &͛{^ŏZ%4ʕ+SZ0bݜ9s"N|a ʃ>$\s*;(ڵ>3fI[n^+ӄmx|\/;,7Jn)4 ,wڡO>yk%5Ž V^O ;}F5J>}ܾ#<2e.2 ^Lii(}}Tv`?ӵx[h^-"+v* lKd֬Yn9믫4a޲e:5.|]{+@L6M*'DF>|[EB V{WOjeYѝ>\M# ɓU }zVyij9)^^+(sye]?9sVI6l{8|A|_{(z{I'ڟOl]v׉>r%U$t.h۷:. _ 2Re2_tǯQ"HYe ;8ⶻ<&({>7Rƾwyzr ȮYwp ʹnL>lҥKݾ$f>}jo,(EF/~P+p6kKyv} /Pmf jR%~: ȷD*M@j\pjo9IPN>Ǎbg 3 3Z_ F'/ u;*_ۗLk A(rR;C_:txZz;؛=նm[U_N9wӼO*a>q䧂|/W)@%b$VQ>>ύrEU&T.h)ӧ:& H<',Y'4 /Y@^d*%G>Gr';Ԋ5S'RK.Q㗡Cd/eeذayvZ`;{>~#W9:,WPnN}}n  3Z_ 2Y ;* r>9x6_ J1Qy)b _^zݼ`F/zr7MNi_|<9A 駟'G .W_Ůs~mվdA \|gn  3Z_l|:62sA;;vj[-<[j젏{b ,Zݼ`2"Ӯ4?*#(8+BGP8|ꩧQB#W9ꨣjg4ۆzW@7<׿'4.h?^OR| 'JYO6f8 k;{N[N1\WW]>%e_ mĈj_?^OJKp-I&@&LU@5i!(WqQ*/ o|LPiTtPeԩn@n6զ"\5GP+^nZp쳏/̘14i^{nZS%(aOB:G9PСqFȀm;:uR* g YmX1\J?b9kNO,+EwUvm޼cHîSUUT@EF9Sjt3Zw@/wiA,X@KP8ܣGu>쓆>*s{Jd`С=dITP~$؁0b0~ŔE_ <n@sjKyZP}堃rO}c{|ݴ~;p7 Ժuk_.bwӂXrڗq[n8|N}TL/^h;n{ /Q~a*/&{=|,8 ^P( M/(U.i5ʾP+paʀ nw0۩bsrg@ {V( S!QzVP`0~dg r' * ;*|bm[k߾jCMPv}%k)^q.؋뙰AkK4U0gfZLP &-χʤIS O?O@lcq:(vi׻U1\J?bD/@Edرc&ǠAT ̞5!zخ1]9#Cl2mPiOiq8õ[ ^CevJLW ի3<7*$ 43[J/ &m\w`$EK.ukv" NힻFٰa[Bk֮QeC2]O?UŮU,Iww (o,}^T^.n;J({[J/ *hm%C(wynqLגi_|gnuB @nL׆裏ԶAyG K.jO>DO>}^|3m440^|E^RBA%(.4<& fҏ썴d3@PQ SAW_J@jvu?DF?[B˗/WeCv}wP}}j۠1ݼ`v/a;w:!(6{T'l :;=z6mT{ &UJd:(v0a0~0n8u EwU읿~*/I(EFyW*ZeCəXp6(?ykN_6gFGOon"ٶpYgvM&{*lQ씳apa@+NS|:ѝF=zx[lq@Ͻ]wU,0 L}enBݲb_ E.BP}e8q"\xwV㗰 ?S|2ZP*>?=z{4j(>RwJguE)gWZVpa@+ @.+2Cu@EOUqmNsAQl?OnBo۶M<,Y3(sydXm?=%(;}Tl5 {el[pG@6i)t54Џ>[m>m9&W0%蛙3g}Qb >\OF>2`jVh4ː!CMC gPu6mR _O Jl}Twmܸ=@E3ltM6M$;e[Ge}a}w_.}>gFtRUVޢE(Pf͚Ck WlN8U]r5׸^CC:Π 4ݼ -[%(a>18A,<淿{ځp饗" 'nPj.݁xBvL4i09PV?}NK.n b uQ|dnd:=g>}M bΜ9j_۫cނRcg.\=@Y1bj)b 1(4_V= 6 [FHvBJyfSm E pvϩ֭[ݪJn~9cMB,Sb)SԾ%LY<} i7բϗo2@%Oefn*NhK֮]VAyfLo}L4ݿL't@8p)IDv{n壏>rJ(cR]ve!JTC} J?>Y.(e}|c??/_V,]kӦ)+.b,DU~P֯_nzvjg8bڶmye8\"a4iO}C=۰a[`lUSmI [wT&LVIy0n82@,ػݱNAsfΗ7M|9n;ϭ6T`~r4U'MV>u]yضEkQtj9ھ}wfm\LуiP-ZnZ/LTn}e=pN(c:Sks7 9s ʝwnW/ڇT Įp8Vo7#FpJ٬nݤ. _ӦMS. D?4Y+N;5j˗/O u;Ez;; >*>mxAYjym޼YcP =~UW}H gdsA(Ʈ?O?u\/@v{[Ot'v{#h,Ӣ=L￿)dOAZ*7kV)￯^#(>ytA8b/ ~wNS%,v?}ɧL}.SiՁ\Ϫ&$FlEt}R K2N( /۶mۏJֺuC=Ti0]yorXXV7\اb:#?3fLN׺qPO-N4Ivޫ'] 7UUUK/V+y4aJϞ=ݪ 9r9'\q@۸qwǪ:&}fQD"on=NOLhʌ3* ~d9\wu mذ!14kRovء(OR-[t7m+Vd|Q} ٲwMWc>}իWi&/2`#n9gu_7(7w͜9S*cǎuh6tYg^+ӄa8[rk/c?@:ujVߍg[NJk*]v6oVcY}yTc/ص2픗@igM&TB\lꘂr]S}TzRWW^/(gsӼpܠاs9ewT:$ wo#('l}3~xE_gغW!Ω[VW_$)lɷnf~y#)-tg*(wE9Ùyj*gϞe!#롊ή ={f}U(|"2~{FOlٲf1Wɮ$BtQ @m+v-c [r*Ҷm[?tw7'`^k2/٧ݿK)ev7 V}SƮ=gj9agͰ7.Mv}kښ]'Ux?If&@ }֔SYMfkʺ\[L֊+R[[VPi~iUWWהiTmd8څB~aoAR$QJӘ~9O h;-)}b/x*s9}@Yw\3yGt5e욒/ /4iƿ@({[CŮik׶u9i?&np-tnS҅~z邏NR]vw~7ni8ꨣdҜcUt]H;|>Pl8p_dIokqm߾m?G}j7yOY%tѝה>׿c #СCU0_uFN9fv5;ӦVCCwt2}w֬Y.,Oc>} Yb.EK,QXI>և9#O?ԭn@F-Zva^e; P]G}fxU{IPr];iӧOFVc9Fե blR%@0&}ƭ?$e̛7kݺ:$_Zj?y:v-ޙ3gPp;s57v0o֭[俽kj; >ݴ$<#j_}`AǢEʴh›0a[倔&OiDҒo|xwT> P`ٴmݼ_/J3.mC&CҳgOzҊ+믿Ykv[t[t'_|E.vi'M=ΓO>9q7ŋݗ,:{NC=zx>`F7Xu2dwӒpᇫ}3J u#m7+IߖP6S'CKTtU9>m 7NL3%d_ mݺ;A/Xՙ ɡdN#O>ĭek߃upnݼSN94h7rē,͵?{^xabzM;qV}wo6m=;蠃38û[1cxoVb0k-X >0 Y>ؾ}{oO<=|{'NLJGvd6;w|M  FV֛ 7o P]o}S7fgqGJamػ$ΝQ^x [W2|=.|jܭO? nS'-6 X-LHrY&,7 6nܘƭ'Y~>{[}S Kk4}t.RYjJvWDwp3tÆ n_>ֿU7]jGwT'MlV]`g i۶j>/v:%mSNu$*/ܜ~ך*@xt2Y-.e&T%K$fNrE@V  ľfrnF}ݽ3f}j9;wQՉ c (@)n0ߟ}Vǀ؁>L扮3Ů rJj̭^:$[ޢo@Y7SagL6fK.$q'%߼y󼣏>ZՁ,\?ڭcһwo(N;MG,7)qd{Z<Oq:vyߎ_yO>X;ةN]?U_ݦ x>h^ֱk>ޚ5oW{1P硉u nR#Fs=M?>m@$"ݤ#TܱO>}{ތi|]`z;9Seo0kT{CS"6)9{݌3SK"w͛ 4(W<L_VC(i&"le2Etgɱ=͛~=2foܸq>;Q]gUl;O>jg/@؋|*.69FCzw}7vUbs oLnSWW6_$=S,V #v}੢;͊"شiS}WOmM0W]tUkymK]tQ, L^|gd~yÆ .\6 8-ZCQc\3$RP` ѣGz&Y٢;NV.(ފ+~EN;| ؁_>DXmN`Ĉ}de5Y)~6;￿w-$f/¾'v}rM~leSlqS`}Q%GQ5M CMVer;9yٳ7ʒ]ySk6kv 'nn;cې9m_>m$P*v1d躚؛:,/{|AElw1AMZ 8dom@Q >\4Ygr;5:8Lsc.4h7~x>sҲe˼ɓ'{_ףGuyf&{ ^ICnv鮾jծR/@$:Ӵh;餓Eۧbaeo޼yhN`aȅM6ng*6[ gl09TP|Tngl/3ƻO35c kخf/[g&zw7p ]vUYea4Z]Ů {zR) vV ,q%\ew?p.JL:z… k׺0g֬]x Zuuu۷ob_2=dRgrȧ^&[D؛Y~}ⷛ[d)&4/Ywڠ{wG&0;lkW&;SS6ۧѨz"gpI˭*={}@ vV ĮV-@1dz]{yw?nw?m ,.TQһ+T G&(_39VӚ]IvtL0Y%tL$Ǝv0aB.M [lbarI'`rۉofΜ^sgV&ED@KU|.u}OMZJ \͔ nh͛7{_g.?s*\(\h2I//UU&n7*{Wbmƍ^׮]U T$oZ(6n;#LZ 0.62={-[v!,Y;#U M PAwu$ɋYMSUY!)F{pI趤rM7 V% v͵ PJrZMlN5X179 ~`v2v3f #ӦMZnUyا R1&D k셴&#$΀/E/߼Kًqn;IvvYL֋n7a={L _{Ķiݶ6v^fAl]U=0v ,n8*HkJrnINg׃q,Rv?7'I$TTvuWoŊu "\24NO tKr2R$ы%9O8)7ۇLH{wݮ… :H՟ c`My'g;Hr`ɵ&<'ɧl^(l5Y"JSL0i#d89^*۽:K+ iv՞&IzY&I~eטi2ZWb;1CgGD"oԨQ>U۶m{DqM]u2bd! 'lr$&$ְ+o/ٿ?K\T'݋wSVG}ʩZk\}$/~g_v%Y-'dtiZ={L< X׫W/UO2F+v6Y(B} "̙3ǫR" KP ~$}/Q: nb˖-Û&{ %9-{AASNުUk@Y[z׹sgE3^ʰD}r&n4Cey8@Շ,IkHD_T͉'X r)ȵ*]{M~0`b +2|r/W?؛ [UF /0殻ree[oU?E^6 T-͘NEVtPv6%qv=sn!}v>ɓn BbƌakYmr4]/#Zj|;" dCVٳ7{l˂5sL﨣R y$&9`~^)V\^Bi^{y<'62r 'x}A S=O6;ykB!9d9c͛7APٴiSOk|l]HoE'w زeKbLeM@f%|s)p y晪^H&[d:x?vZk<[vCy۷W祉Y` (sE_L>}m۶GuVW9E%MҤ*D3f$"F̛74hP=wCdn}"0^z) {+T8M @}nM{ >nh͚5)ufdHPU&D_̵^(y^s5I \MNUUUby3Et)Ǎ~A3OlgE_'QUM@a2]tYs7nn:oĉgx1fs(!6/BF` 0J]K.Q5M昴DGr=zxÆ Kg[|'ȑ#N:)_6o,%5sYgy7ovE]p{&p'7Yڵk 00ah"TvO?8f{49^X>@y0Z?5ұHMmbΝy.MsI˅^mVodIڭmb{,R]~8K(|&G`8oŊu VZS4Yj(0Uħn&gSS@~p-y~]tE=ŋKj/eow׷o_o}UǑsBd/՟TUS;y `yH xsw@dҥpB W}{&L~,@90:osW3EZۿXӟ|=J$͑XP\]M>}$e 544v@lݺջU} Jr}k ԢN4ߔYB=[m۪I1JIu|1'K&M'P:=Hn{S{R=]MR裏/_Ml2﨣R,|`Y0TH,O6an)~)J?ro`Et4NT&Ju"5Mbeחwr@Au0#BJʴk{7ݱ< +vm6mڨA2/B,\GԔq8Z30>S'Y`7e5E,HM&}O.|=&e/,M}a%eZ=m6w\H֙x@թ 3[]&gOԜm8cރq~wbM'k/5@٫~HMZ}YYnguϪbM3z:$Pp-L,bK[d;uW(-W?-c:٤@E٭mv0}%۹/ty[R?$R&S^(~&D_I-[zL2kժ?d`ª3_}HN> Wwʹϣ^FG/'ESњskGr3 <}(!L5~^mNtرdWϝ$jƷ79G3ٛ"յ/2Y~lz/3Io^:Lcp=ܒ[}WS}LdۘnW&D_I+[v; fK/U%غxaձǦ3ǧb8]"յr=ؾ-:+jmW,y;-J\n|bx$gyE&l6 [-Ӗm_^+%v쾔2'G"A^}u쀲Xr4GBվ!lw_QakpP4/Nڴiƛ~'"ur3?Hhݲż>dnY>t$`ufvFm۶D:{-ZP!5m/N$80TS5{};MY|F۴Loeʔn>9I}4F?N0Pn:OtWHhܢˋTՌdێniXe2!X!ٳݻEa{s4VO&:hEu}Ow3IߺI&1_w@ B*ϧ:r bڶ*?iR'dDуvN h"w!g߿:YfI{B(Z]{ìu4%V&Z?Qe4\U-j&}I n9rUgdmhnAvO?UHM }Jr*L6(HĻ뮻k׺5kxwyg✺9l4'ɺ|ӟIhv}r-l7&2K_w*NO ZݧT[ Ֆ;i/7Gkǹ Lj꾧;8\ofp]%gODeh4~ Ç'xvkk!z855XN:Z GbK4V[N!U=Sl)͖<0iMA` "5u~|*?-̏?[صr`͢2Ύ;Lܸq;Έaoȑޮcb2DuHV 1H 7aMwGDQg}+eZtHnYߌjߨ=(7V7=Hɪ2XHMާ"2Eu}Oo#~dc2K _ViӦMb N+Ҳzj .ND2xTRӿat5e:-:Mٗ jR%-N+|։Щ-PbOv7Gk3uY$tz[<g:~peEחwdZ4Vw[ 1׊*vjAy~;[xqb-[Ԅ7h?-bϳ۔}*t1bVǧ:2!NYgX͞f_< U5c"Zszɫ-b%qTu L=פ\|oK"|Mo߾|4#cL: P")bI16)pcoLw2Cٿ⏹eB\(Y,Nrvc4VkSZZc'(U5N}Dc"vSw[P9-M>쓘zժUX%rN]__u]<p|F4;CBva8AԚ#n NUM bw{41s>V|?.y4$m[Rer"w4VhMlӱ"Rb})R];?R=nwb27J(I5nBǮwurMJ$~zgma"K=1cFI몪*~7#KM=BDp|tN;-oA^_}Ni{ɖGubF_ǩRUS;-"]ۘ{YFOTyӄ ?HR$D(iA@aӮ];OLW}vwlo t?3ȺW!Ğl|!85c~<~J,~[ko'͢X,|͉` ־馛:/d2@;\_bghqI*f4EGǩRU2+t֌>-*f^w)S]w[ TUIc$E5S2;M4th4;%KܱЊ{'O}QLFtC[m[ϛࢊ])}-NoSUSp%M0_1Anʎ4Or<5:Ȼ)Sx˗/wIƲe7p׽{w>8v{MvpQ~M{2[2`C_R멳I7Zx~|G}Ojr"vHV PQ캏Mhyv]zѣsz7ntRKކ 9sxuuu'|t颎3OYbbUEUUǩ=-ߟk$ik&Ȣ9zSU=n5cpN}&}MxksO .?&^`vZwܵ>;}6lw'/@ir$|c}Jv-P5t.n9E{~60-8GHtPQL0<iZjr!n{衇zʛT7.\\2Dn쿵mmSNƎ(۾䵯u{3}&K(s}}S'|dFb|??׃Q XwRn[4O^mi~p|~Hc[ edʒL4M cW™k;8.Hїo⏹e|U-(b%RoPThHMԉ/.|-MhAKҼ,2ۤ(>Ƽ7U2!o;F\W:S,U5uϸf{n4eGTLJNSIX2,7irI P:.kw۔/s=ul߹dDj}}10юǸe@~j˪)4Y+]۸E@ vҮ 4E;$oT&¼/mThǺz4ʱ2nh$V.ܢ KL3Y+zҲdɅ&1 \4VwN|tSHlOnfiODk⯸@溾SUM*Ne Rd?Sঢ়_H-vJ &%9MvT"4=:|0\Xl:joӟ);b^πۛ2 XO͏t/NOur<ɯ%~s&+D%v2{ X1u2RO(+ T$}OӄeK >v}[Fcbv`'4?<ft| H(&=M4yLt-t|(}zDxI{)G5c2 |+҆` ^wϴHM"њnr3Uյge@c~^0TIb޽IrYoD{ q @l\!N (TL;0~ww'rp%ÅDua<l!x!:6={8gvvo3OշVZ?S n|&<fXvӬTf6L _kpt\?*[`5\x4|sExr||HM͵cfhooP'{;.UA_2ߏkleo$^un\2.ʏYd||\O<{ʟ0SEx>x[!_Lv[&eK[UOk$C:ـ;Ex^@ «MږdMfhzu#7%yxt\[i˼?4,ϸV ώǹRSf';yxwZ,ӨKz:h3U4O/<~fc\S"?e,|9.4ƹBSf9Ǻdpx ̞nQ=e8h3U4\(^c7ޣZH'.?|2QYj06|fNtj1)0#v|@|e8h3U4ZVc|'zL>۲Ho[g)WHQ4L-hߑN.Oznӏׄ֬L wzyko&O%NzQC5\oIJ/Z\ 2[>pO̎nZОnoߍ0SExm׭~-O^$+-/#nKzW<$Ң|{s|$0mv%yxtkcO+“KӬze?Mepߚw0EwkЖoW8ſ `eկk3^&lݗ5atX76Fq9xd|wF}}"qqbtdOAa:Cr2L^n^ ]y8,`6k_7׆Q 7&L׸nFe^^P|y1fɞ#KzEi34S_7~=M' _yϸ,#ͪ+'9i\9si\`eG^˗LҸ,T߿C;,^XE.] {^=>..m YEaK5yUq `;ZJyq2"ݼ jϑs'|x¿KAY|jOu%`E{בkZn{럯{yqti~im>|k5ѻZK7+_?eG[q &`n[ɫ+߉0lC<|>~c(?d=qI6E39`<<<Mgxfl^}dT_k0tg͹$q;frx18N:yd}jEx|5ͪ9uiju- 50{ޫ?לhfjTK-k%`/rKs`TAlIp[ɮ~L4;$YV4uw%Y1<<[,z:odeݢiQ}‹#[qB& 09)ʷǏIY6+ .i?/{ʇ`-Oyhc}Z^epkmu{[,L@ݢewޣk,pZ?>_l/ͫ7{ϷWNw+ć~W[ I-{|"1)ꓣwT`,f$_Ċ4e3N_NJk-7h[owpyuRۉ4?Ob,` ?VJQ4.lD} 8LzlcѸ[W9_Kx}h3˦텟~a,+“[ˡ+Rxre&AZTnux:yu(~!Gk0ly;ÍsX!7$aq)eioe-k$Yq `+;vNY)޼J(l4c,&.y]sn$ܚG%Ʀ,ѻÀu#R0Ң|W˺9$WW47xl\g+өt[a)WVEY6 ന}:®kY;$ -_nnG2ext>|< ';> .KҜ_&/u,pz'㱏LQ4.$oвvKVj\Yi66+W? i|:l yx>.j̲ik9rz7G'TqnVvOR5 )x?FnHzW<$]iQ~el[[9zXĚh3˦\~3%{;947 n&ExQF~cޣm :ǛcZ1'q bh[ٺ,ǽ-@zeNrIQ+.LN66c=mx؝`dݗq5fMQ8-Ÿ]!okUiY?ύk&7' L Kn^Z0NN&; l_ѭgEY6- ࢿoxXmfu_ M7omnMn .]{ܻ>ch{܄7e\iQ9?Wǟ5 `fٔ4;Ex#S53?X?Gq `Rz}*ݼ`zevV9:k6,5q `#<oזou ዗l;'iQG5הs'G`-stk׎̄޽-{8 <~*5I<6~؆v>Ix'vST?]nן!w윸 0³񿡵 .|1Ç*O|NÃoc^?G6W=_ڜ%#~f¥p[\kڣ eExInS/nݐ+ߌ)-w54"YMtI퍍Kos`s떿Q4ppיhl?W5kӇƦߧ/d26ϧv9HxEd/9G%>+q\b]i3R 4.z=>G& _N.ܸ̆Z-ZSTt7'&7u{sK'-t{?~i3R 46SjCӫ^WHiQ~c #nMv_uj};ILhҫ?6_~9OIQ~:ɮ{\ci3R 4Fos 9~4<\rk:/' G'pcZ$/uqv\xչqY`=zUݼzAZOyҬT/:O]v(Zo?R?<\^[')'!DKN^卣 )Wpl ?{ͽx ?ǻRzCS}Yoܜd0C<卣! )4dݼ|f\cDNi7WdGݢySVp[s`d=i|%E񾽰4iwd7_xv<~fK67~`6S!0ҼB ;;vNg|[>rRIC`FyƛH `VU|e?9ͪW&{53,>3gOAiChWn`흼:[J5ό0S,J:7/1;Ϸ%a`m-} -{͵i<ˤxC@C|f4XCܫ^U3Eyutp޼`_ with: .. code-block:: shell $ pip install curies The most recent code and data can be installed directly from GitHub with: .. code-block:: shell $ pip install git+https://github.com/cthoyt/curies.git .. toctree:: :maxdepth: 2 :caption: Contents: tutorial reconciliation discovery struct api services/index typing w3c preprocessing database dataframe triples biopragmatics-curies-aa8bd37/docs/source/preprocessing.rst000066400000000000000000000127621525104130300241700ustar00rootroot00000000000000############################## Converter with Preprocessing ############################## When simple expansion and contraction aren't enough, and you want to inject global or context-specific rewrite rules, you can wrap a :class:`curies.Converter` and preprocessing rules encoded in an instance of :class:`curies.PreprocessingRules` inside a :class:`curies.PreprocessingConverter`. ********** Rewrites ********** For example, you always want to fix legacy references to the ``OBO_REL`` namespace: .. code-block:: python import curies from curies import PreprocessingRules, PreprocessingConverter, PreprocessingRewrites rules = PreprocessingRules( rewrites=PreprocessingRewrites( full={"OBO_REL:is_a": "rdfs:subClassOf"}, ), ) converter = curies.get_obo_converter() converter = PreprocessingConverter.from_converter(converter, rules=rules) parsed = converter.parse_curie("OBO_REL:is_a") assert parsed == ReferenceTuple("rdfs", "subClassOf") Similarly, there may be a whole class of references that need to be fixed based on their prefix, such as the ``APOLLO:SV_`` references that are mangled by the OWLAPI due to the OBO Foundry's PURL rules .. code-block:: python import curies from curies import PreprocessingRules, PreprocessingConverter, PreprocessingRewrites rules = PreprocessingRules( rewrites=PreprocessingRewrites( prefix={"APOLLO:SV_": "APOLLO_SV:"}, ) ) converter = curies.get_obo_converter() converter = PreprocessingConverter.from_converter(converter, rules=rules) parsed = converter.parse_curie("APOLLO:SV_1234567") assert parsed == ReferenceTuple("APOLLO_SV", "1234567") The CURIE and URI rewrites are unified. Therefore, you can also use a URI as a rewrite, such as handling Creative Commons license URLs, which unfortunately aren't themselves part of a semantic space for licenses. Luckily, SPDX is, and we can remap to that. .. code-block:: python import curies from curies import PreprocessingRules, PreprocessingConverter, PreprocessingRewrites rules = PreprocessingRules( rewrites=PreprocessingRewrites( full={ "http://creativecommons.org/licenses/by/3.0/": "spdx:CC-BY-3.0", }, ) ) converter = curies.get_obo_converter() converter.add_prefix("spdx", "https://spdx.org/licenses/") converter = PreprocessingConverter.from_converter(converter, rules=rules) parsed = converter.parse_uri("http://creativecommons.org/licenses/by/3.0/") assert parsed == ReferenceTuple("spdx", "CC-BY-3.0") Some rewrite rules only apply to a specific resource, because of its own quirks in curation or encoding. For example, CHMO encodes OrangeBook entries with ``orange`` as a prefix, which is not typically specific enough to warrant curating ``orange`` as a prefix, e.g., in the Bioregistry .. code-block:: python import curies from curies import PreprocessingRules, PreprocessingConverter, PreprocessingRewrites rules = PreprocessingRules( rewrites=PreprocessingRewrites( resource_prefix={ "CHMO": {"orange:": "orangebook:"}, }, ), ) converter = curies.get_obo_converter() converter.add_prefix("orangebook", "https://bioregistry.io/orangebook:") converter = PreprocessingConverter.from_converter(converter, rules=rules) parsed = converter.parse_curie("orange:10.2.1.1.3") assert parsed == ReferenceTuple("orangebook", "10.2.1.1.3") Similarly, this can be used to inject knowledge about resources that improperly import EDAM sub-trees such as MCRO, which uses ``format`` as a prefix where it means ``edam.format`` ******** Blocks ******** Some references are _never_ informative, and can be configured to be thrown away, such as ``Bgee:curators``, ``BioGRID:curators``, ``GROUP:OBI``, and similar group curation flags. .. code-block:: python import curies from curies import PreprocessingRules, PreprocessingConverter, PreprocessingBlocklists rules = PreprocessingRules( blocklists=PreprocessingBlocklists( full=["Bgee:curators", "BioGRID:curators", "GROUP:OBI"], ), ) converter = curies.get_obo_converter() converter = PreprocessingConverter.from_converter(converter, rules=rules) # raises a BlocklistError converter.parse_curie("GROUP:OBI") Blocklists cause throwing an exception that can be handled by downstream code, such as returning a None. This is done because in some places, it's nice to have the distinction between ``None`` being returned by parsing failing, versus actively being blocked. This can be toggled with the ``block_action`` argument. ************************ Suffix Post-processing ************************ URIs from some prefixes that are known to sometimes have unneeded suffixes can be configured to be stripped in the following way .. code-block:: python import curies from curies import PreprocessingRules, PreprocessingConverter, PostprocessingRewrites converter = Converter.from_prefixes( {"emedicine": "http://emedicine.medscape.com/article/"} ) rules = PreprocessingRules( postprocessing=PostprocessingRewrites( suffix={ "emedicine": "-overview", }, ), ) converter = PreprocessingConverter.from_converter(converter, rules=rules) parsed = converter.parse_curie("http://emedicine.medscape.com/article/276512-overview") assert parsed == ReferenceTuple("emedicine", "276512") biopragmatics-curies-aa8bd37/docs/source/reconciliation.rst000066400000000000000000000252241525104130300243040ustar00rootroot00000000000000################ Reconciliation ################ Reconciliation is the high-level process of modifying an (extended) prefix map with domain-specific rules. This is important as it allows for building on existing (extended) prefix maps without having to start from scratch. Further, storing the rules to transform an existing prefix map allows for high-level discussion about the differences and their reasons. As a specific example, the `Bioregistry `_ uses ``snomedct`` as a preferred prefix for the Systematized Nomenclature of Medicine - Clinical Terms (SNOMED-CT). The OBO Foundry community prefers to use ``SCTID`` as the preferred prefix for this resource. Rather than maintaining a different extended prefix map than the Bioregistry, the OBO Foundry community could enumerate its preferred modifications to the base (extended) prefix map, then create its prefix map by transforming the Bioregistry's. Similarly, a consumer of the OBO Foundry prefix map who's implementing a resolver might want to override the URI prefix associated with the `Ontology of Vaccine Adverse Events (OVAE) `_ to point towards the Ontology Lookup Service instead of the default OntoBee. There are two operations that are useful for transforming an existing (extended) prefix map: 1. **Remapping** is when a given CURIE prefix or URI prefix is replaced with another. See :func:`curies.remap_curie_prefixes` and :func:`curies.remap_uri_prefixes`. 2. **Rewiring** is when the correspondence between a CURIE prefix and URI prefix is updated. See :func:`curies.rewire`. Throughout this document, we're going to use the following extended prefix map as an example to illustrate how these operations work from a high level. .. code-block:: json [ {"prefix": "a", "uri_prefix": "https://example.org/a/", "prefix_synonyms": ["a1"]}, {"prefix": "b", "uri_prefix": "https://example.org/b/"} ] ************************ CURIE Prefix Remapping ************************ CURIE prefix remapping is configured by a dictionary from existing CURIE prefixes to new CURIE prefixes. The following rules are applied for each pair of old/new prefixes: 1. New prefix exists ==================== If the new prefix appears as a prefix synonym in the record corresponding to the old prefix, they are swapped. This means applying the CURIE prefix remapping ``{"a": "a1"}`` results in the following .. code-block:: json [ {"prefix": "a1", "uri_prefix": "https://example.org/a/", "prefix_synonyms": ["a"]}, {"prefix": "b", "uri_prefix": "https://example.org/b/"} ] If the new prefix appears as a preferred prefix or prefix synonym for any other record, one of two things can happen: 1. Do nothing (lenient) 2. Raise an exception (strict) This means applying the CURIE prefix remapping ``{"a": "b"}`` results in either no change or an exception being raised. 2. New prefix doesn't exist, old prefix exists ============================================== If the old prefix appears in a record in the extended prefix map as a preferred prefix: 1. Replace the record's preferred prefix with the new prefix 2. Add the record's old preferred prefix to the record's prefix synonyms This means applying the CURIE prefix remapping ``{"a": "c"}`` results in the following .. code-block:: json [ {"prefix": "c", "uri_prefix": "https://example.org/a/", "prefix_synonyms": ["a", "a1"]}, {"prefix": "b", "uri_prefix": "https://example.org/b/"} ] Similarly, if the old prefix appears in a record in the extended prefix map as a prefix synonym, do the same. This means applying the CURIE prefix remapping ``{"a1": "c"}`` results in the following .. code-block:: json [ {"prefix": "c", "uri_prefix": "https://example.org/a/", "prefix_synonyms": ["a", "a1"]}, {"prefix": "b", "uri_prefix": "https://example.org/b/"} ] 3. New prefix doesn't exist, old prefix doesn't exist ===================================================== If neither the old prefix nor new prefix appear in the extended prefix maps, one of two things can happen: 1. Do nothing (lenient) 2. Raise an exception (strict) *********************************** Transitive CURIE Prefix Remapping *********************************** There's a special case of CURIE prefix remapping where one prefix is supposed to overwrite another. For example, in the Bioregistry, the `Gene Expression Omnibus `_ is given the prefix ``geo`` and the `Geographical Entity Ontology `_ is given the prefix ``geogeo``. OBO Foundry users will want to rename the Gene Expression Omnibus record to something else like ``ncbi.geo`` and rename ``geogeo`` to ``geo``. Taken by themselves, these two operations would not accomplish the desired results: 1. Remapping with ``{"geo": "ncbi.geo"}`` would retain ``geo`` as a CURIE prefix synonym 2. Remapping with ``{"geogeo": "geo"}`` would not change the mapping as ``geo`` is already part of a different record. The :func:`curies.remap_curie_prefixes` implements special logic to identify scenarios where two (or more) remappings are dependent (we're calling these *transitive remappings*) and apply them in the expected way. Therefore, we see the following .. code-block:: python from curies import Converter, Record, remap_curie_prefixes converter = Converter( [ Record( prefix="geo", uri_prefix="https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=", ), Record(prefix="geogeo", uri_prefix="http://purl.obolibrary.org/obo/GEO_"), ] ) remapping = {"geo": "ncbi.geo", "geogeo": "geo"} converter = remap_curie_prefixes(converter, curie_remapping) assert converter.records == [ Record( prefix="geo", prefix_synonyms=["geogeo"], uri_prefix="http://purl.obolibrary.org/obo/GEO_", ), Record( prefix="ncbi.geo", uri_prefix="https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=", ), ] ``geogeo`` is maintained as a CURIE prefix synonym for the Geographical Entity Ontology's record. Synonyms of Gene Expression Omnibus would also be retained. .. note:: This is not the same as an "overwrite" which would delete the original ``geo`` operation. This package expects that you give a new CURIE prefix to all "overwritten" records such that no records are lost. .. warning:: Primary prefixes must be used when doing transitive remappings. Handling synonyms proved to be too complex. Therefore, if you use a CURIE prefix remapping like in the following, you will get an exception. .. code-block:: converter = Converter([ Record( prefix="geo", prefix_synonyms=["ggg"], uri_prefix="https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=", ), Record(prefix="geogeo", uri_prefix="http://purl.obolibrary.org/obo/GEO_"), ]) curie_remapping = {"ggg": "ncbi.geo", "geogeo": "geo"} ********************** URI Prefix Remapping ********************** URI prefix remapping is configured by a mapping from existing URI prefixes to new URI prefixes. The rules work exactly the same as with CURIE prefix remapping, but for the :data:`curies.Record.uri_prefix` and :data:`curies.Record.uri_prefix_synonyms` fields. ********** Rewiring ********** Rewiring is configured by a dictionary from existing CURIE prefixes to new URI prefixes. The following rules are applied for each pair of CURIE prefix/URI prefix: CURIE prefix exists, URI prefix doesn't exist ============================================= If the CURIE prefix appears as either the preferred prefix or a prefix synonym, do the following 1. Replace the record's preferred URI prefix with the new URI prefix 2. Add the record's old preferred URI prefix to the record's URI prefix synonyms This means applying the rewiring ``{"b": "https://example.org/b_new/"}`` results in the following .. code-block:: json [ {"prefix": "a", "uri_prefix": "https://example.org/a/", "prefix_synonyms": ["a1"]}, {"prefix": "b", "uri_prefix": "https://example.org/b_new/", "uri_prefix_synonyms": ["https://example.org/b/"]} ] CURIE prefix exists, URI prefix exists ====================================== If the CURIE prefix and URI prefix both appear in the extended prefix map, there are three possibilities. 1. If they are in the same record and the URI prefix is already the preferred prefix, then nothing needs to be done. This means that the rewiring ``{"a": "https://example.org/a/"}`` results in no change. 2. If they are in the same record and the URI prefix is a URI prefix synonym, then the URI prefix synonym is swapped with the preferred URI prefix. This means if we have the following extended prefix map .. code-block:: json [ {"prefix": "a", "uri_prefix": "https://example.org/a/", "uri_prefix_synonyms": ["https://example.org/a1/"]} ] and apply ``{"a": "https://example.org/a1/"}``, we get the following result .. code-block:: json [ {"prefix": "a", "uri_prefix": "https://example.org/a/", "uri_prefix_synonyms": ["https://example.org/a1/"]} ] 3. If they appear in different records, then either do nothing (lenient) or raise an exception (strict) CURIE prefix doesn't exist, URI prefix doesn't exist ==================================================== If the CURIE prefix doesn't appear in the extended prefix map, then nothing is done. Adding fully novel content to the extended prefix map can be done with other operations such as :meth`:curies.Converter.add_record` or :func:`curies.chain`. .. note:: There is discussion whether this case could be extended with the following: if the CURIE prefix doesn't exist in the extended prefix map, then the pair is simply appended. This means applying the rewiring ``{"c": "https://example.org/c"}`` results in the following .. code-block:: json [ {"prefix": "a", "uri_prefix": "https://example.org/a/", "prefix_synonyms": ["a1"]}, {"prefix": "b", "uri_prefix": "https://example.org/b/"}, {"prefix": "c", "uri_prefix": "https://example.org/c/"} ] This is not included in the base implementation because it conflates the job of "rewiring" with appending to the extended prefix map CURIE prefix doesn't exist, URI prefix exists ============================================= If the URI prefix appears as either a preferred URI prefix or as a URI prefix synonym in any record in the extended prefix map, do one of the following: 1. Do nothing (lenient) 2. Raise an exception (strict) biopragmatics-curies-aa8bd37/docs/source/services/000077500000000000000000000000001525104130300223665ustar00rootroot00000000000000biopragmatics-curies-aa8bd37/docs/source/services/index.rst000066400000000000000000000002351525104130300242270ustar00rootroot00000000000000########## Services ########## .. automodule:: curies.cli .. toctree:: :maxdepth: 1 :caption: Services: resolver_service mapping_service biopragmatics-curies-aa8bd37/docs/source/services/mapping_service.rst000066400000000000000000000002541525104130300262740ustar00rootroot00000000000000############################ Identifier Mapping Service ############################ .. automodapi:: curies.mapping_service :no-inheritance-diagram: :no-heading: biopragmatics-curies-aa8bd37/docs/source/services/resolver_service.rst000066400000000000000000000002171525104130300265010ustar00rootroot00000000000000################## Resolver Service ################## .. automodapi:: curies.resolver_service :no-inheritance-diagram: :no-heading: biopragmatics-curies-aa8bd37/docs/source/struct.rst000066400000000000000000000130161525104130300226220ustar00rootroot00000000000000################# Data Structures ################# A *semantic space* is a collections of identifiers for concepts. For example, the Chemical Entities of Biomedical Interest (ChEBI) has a semantic space including identifiers for chemicals. Within ChEBI's semantic space, `138488` corresponds to the chemical `alsterpaullone `_. .. warning:: `138488` is a *local unique identifier*. Other semantic spaces might use the same local unique identifier to refer to a different concept in their respective domain. Therefore, local unique identifiers should be qualified with some additional information saying what semantic space it comes from. The two common formalisms for doing this are Uniform Resource Identifiers (URIs) and Compact URIs (CURIEs): .. image:: syntax_demo.svg :alt: Demo of URI and CURIE for alsterpaullone. In many applications, it's important to be able to convert between CURIEs and URIs. Therefore, we need a data structure that connects the CURIE prefixes like ``CHEBI`` to the URI prefixes like ``http://purl.obolibrary.org/obo/CHEBI_``. ************* Prefix Maps ************* A prefix map is a dictionary data structure where keys represent CURIE prefixes and their associated values represent URI prefixes. Ideally, these are constrained to be bijective (i.e., no duplicate keys, no duplicate values), but this is not always done in practice. Here's an example prefix map containing information about semantic spaces from a small selection of OBO Foundry ontologies: .. code-block:: json { "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", "MONDO": "http://purl.obolibrary.org/obo/MONDO_", "GO": "http://purl.obolibrary.org/obo/GO_" } Prefix maps have the benefit of being simple and straightforward. They appear in many linked data applications, including: - the ``@prefix`` declarations at the top of Turtle (RDF) documents and SPARQL queries - `JSON-LD `_ - XML documents - OWL ontologies .. note:: Prefix maps can be loaded using :meth:`curies.Converter.from_prefix_map`. *However*, prefix maps have the main limitation that they do not have first-class support for synonyms of CURIE prefixes or URI prefixes. In practice, a variety of synonyms are used for both. For example, the NCBI Taxonomy database appears with many different CURIE prefixes: ============== ==================================== CURIE Prefix Resource(s) ============== ==================================== ``taxonomy`` Identifiers.org, Name-to-Thing ``taxon`` Gene Ontology Registry ``NCBITaxon`` OBO Foundry, Prefix Commons, OntoBee ``NCBITAXON`` BioPortal ``NCBI_TaxID`` Cellosaurus ``ncbitaxon`` OLS ``P685`` Wikidata ``fj07xj`` FAIRsharing ============== ==================================== Similarly, many different URIs can be constructed for the same ChEBI local unique identifier. Using alsterpaullone as an example, this includes (many omitted): ==================================================== =================== URI Prefix Provider ==================================================== =================== ``https://www.ebi.ac.uk/chebi/searchId.do?chebiId=`` ChEBI (first-party) ``https://identifiers.org/CHEBI:`` Identifiers.org ``https://identifiers.org/CHEBI/`` Identifiers.org ``http://identifiers.org/CHEBI:`` Identifiers.org ``http://identifiers.org/CHEBI/`` Identifiers.org ``http://purl.obolibrary.org/obo/CHEBI_`` OBO Foundry ``https://n2t.net/chebi:`` Name-to-thing ==================================================== =================== In practice, we need to be able to support the fact that there are many CURIE prefixes and URI prefixes for most semantic spaces as well as specify which CURIE prefix and URI prefix is the "preferred" one in a given context. Prefix maps, unfortunately, have no way to address this. Therefore, we're going to introduce a new data structure. .. _epms: ********************** Extended Prefix Maps ********************** Extended Prefix Maps (EPMs) address the issues with prefix maps by including explicit fields for CURIE prefix synonyms and URI prefix synonyms while maintaining an explicit field for the preferred CURIE prefix and URI prefix. An abbreviated example (just containing an entry for ChEBI) looks like: .. code-block:: json [ { "prefix": "CHEBI", "uri_prefix": "http://purl.obolibrary.org/obo/CHEBI_", "prefix_synonyms": ["chebi"], "uri_prefix_synonyms": [ "https://identifiers.org/chebi:" ] } ] An EPM is simply a list of records (see :class:`curies.Record` and :class:`curies.Records`). EPMs have the benefit that they are still encoded in JSON and can easily be encoded in YAML, TOML, RDF, and other schemata. Further, prefix maps can be automatically upgraded into EPMs (with some caveats) using :func:`curies.upgrade_prefix_map`. .. note:: We are introducing this as a new standard in the :mod:`curies` package. They can be loaded using :meth:`curies.Converter.from_extended_prefix_map`. We provide a Pydantic model representing it. Later, we hope to have an external, stable definition of this data schema. A JSON schema for EPMs is available at https://w3id.org/biopragmatics/schema/epm.json. It can be updated at https://github.com/biopragmatics/curies/tree/main/docs/make_schema.py. biopragmatics-curies-aa8bd37/docs/source/syntax_demo.svg000066400000000000000000002775051525104130300236360ustar00rootroot00000000000000biopragmatics-curies-aa8bd37/docs/source/triples.rst000066400000000000000000000002271525104130300227600ustar00rootroot00000000000000######### Triples ######### .. automodapi:: curies.triples :no-inheritance-diagram: :no-heading: :include-all-objects: :skip: Triple biopragmatics-curies-aa8bd37/docs/source/tutorial.rst000066400000000000000000001007211525104130300231410ustar00rootroot00000000000000################# Getting Started ################# ******************* Loading a Context ******************* There are several ways to load a context with this package, including: 1. pre-defined contexts 2. contexts encoded in the standard prefix map format 3. contexts encoded in the standard JSON-LD context format 4. contexts encoded in the extended prefix map format Loading a pre-defined context ============================= There exist many registries of semantic spaces that include CURIE prefixes, URI prefixes, sometimes synonyms, and other associated metadata. The Bioregistry provides a `detailed overview `_ of the registries available. This package exposes a few high quality registries that are internally consistent (i.e., are bijective). ============== ========================================== Name Function ============== ========================================== Bioregistry :func:`curies.get_bioregistry_converter` OBO Foundry :func:`curies.get_obo_converter` Prefix Commons :func:`curies.get_prefixcommons_converter` Monarch :func:`curies.get_monarch_converter` Gene Ontology :func:`curies.get_go_converter` ============== ========================================== These functions can be called directly to instantiate the :class:`curies.Converter` class, which is used for compression, expansion, standardization, and other operations below. .. code-block:: python import curies # Uses the Bioregistry, an integrative, comprehensive registry bioregistry_converter = curies.get_bioregistry_converter() # Uses the OBO Foundry, a registry of ontologies obo_converter = curies.get_obo_converter() # Uses the Monarch Initiative project-specific context monarch_converter = curies.get_monarch_converter() Loading Prefix Maps =================== A prefix map is a dictionary whose keys are CURIE prefixes and values are URI prefixes. An abridged example using OBO Foundry preferred CURIE prefixes and URI prefixes is .. code-block:: json { "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", "MONDO": "http://purl.obolibrary.org/obo/MONDO_", "GO": "http://purl.obolibrary.org/obo/GO_" } Prefix maps can be loaded using the :func:`curies.load_prefix_map`. First, a prefix map can be loaded directly from a Python data structure like in .. code-block:: python import curies prefix_map = {"CHEBI": "http://purl.obolibrary.org/obo/CHEBI_"} converter = curies.load_prefix_map(data) This function also accepts a string with a HTTP, HTTPS, or FTP path to a remote file as well as a local file path. .. warning:: Ideally, prefix maps are *bijective*, meaning that both the keys and values are unique. The Python dictionary data structure ensures that keys are unique, but sometimes values are repeated. For example, the CURIE prefixes ``DC`` and ``DCTERMS`` are often used interchangeably with the URI prefix for the `Dublin Core Metadata Initiative Terms `_. Therefore, many prefix maps are not bijective like .. code-block:: json { "DC": "http://purl.org/dc/terms/", "DCTERMS": "http://purl.org/dc/terms/" } If you load a prefix map that is not bijective, it can have unintended consequences. Therefore, an error is thrown. You can pass ``strict=False`` if you don't mind having unsafe data. A better data structure for situations when there can be CURIE synonyms or even URI prefix synonyms is the *extended prefix map* (see below). If you're not in a position where you can fix data issues upstream, you can try using the :func:`curies.upgrade_prefix_map` to extract a canonical extended prefix map from a non-bijective prefix map. Loading Extended Prefix Maps ============================ Extended prefix maps (EPMs) address the issues with prefix maps by including explicit fields for CURIE prefix synonyms and URI prefix synonyms while maintaining an explicit field for the preferred CURIE prefix and URI prefix. An abbreviated example (just containing an entry for ChEBI) looks like: .. code-block:: json [ { "prefix": "CHEBI", "uri_prefix": "http://purl.obolibrary.org/obo/CHEBI_", "prefix_synonyms": ["chebi"], "uri_prefix_synonyms": [ "https://identifiers.org/chebi:" ] } ] Extended prefix maps can be loaded with :func:`curies.load_extended_prefix_map`. First, a prefix map can be loaded directly from a Python data structure like in .. code-block:: python import curies epm = [ { "prefix": "CHEBI", "uri_prefix": "http://purl.obolibrary.org/obo/CHEBI_", "prefix_synonyms": ["chebi"], "uri_prefix_synonyms": ["https://identifiers.org/chebi:"], } ] converter = curies.load_extended_prefix_map(data) An extended prefix map can be loaded from a remote file via HTTP, HTTPS, or FTP with .. code-block:: python import curies url = "https://raw.githubusercontent.com/mapping-commons/sssom-py/master/src/sssom/obo.epm.json" converter = curies.load_extended_prefix_map(url) Similarly, an extended prefix map stored in a local file can be loaded with the following. This works with both :class:`pathlib.Path` and vanilla strings. .. code-block:: python from pathlib import Path from urllib.request import urlretrieve import curies url = "https://raw.githubusercontent.com/mapping-commons/sssom-py/master/src/sssom/obo.epm.json" path = Path.home().joinpath("Downloads", "obo.epm.json") urlretrieve(url, path) converter = curies.load_extended_prefix_map(path) Loading JSON-LD Contexts ======================== A `JSON-LD context `_ allows for embedding of a simple prefix map within a linked data document. They can be identified hiding in all sorts of JSON (or JSON-like) content with the key ``@context``. JSON-LD contexts can be loaded using :meth:`curies.Converter.from_jsonld`. First, a JSON-LD context can be loaded directly from a Python data structure like in .. code-block:: python import curies data = {"@context": {"CHEBI": "http://purl.obolibrary.org/obo/CHEBI_"}} converter = curies.load_jsonld_context(data) .. note:: This correctly handles the more complex data structures including ``@prefix`` noted in `here `_. A JSON-LD context can be loaded from a remote file via HTTP, HTTPS, or FTP with .. code-block:: python import curies url = "https://raw.githubusercontent.com/biopragmatics/bioregistry/main/exports/contexts/semweb.context.jsonld" converter = curies.load_jsonld_context(url) A JSON-LD context stored in a local file can be loaded with the following. This works with both :class:`pathlib.Path` and vanilla strings. .. code-block:: python from pathlib import Path from urllib.request import urlretrieve import curies url = "https://raw.githubusercontent.com/biopragmatics/bioregistry/main/exports/contexts/semweb.context.jsonld" path = Path.home().joinpath("Downloads", "semweb.context.jsonld") urlretrieve(url, path) converter = curies.load_jsonld_context(path) Loading SHACL ============= The `shapes constraint language (SHACL) `_ can be used to represent prefix maps directly in RDF using the `sh:prefix` and `sh:namespace` predicates. Therefore, the simple ChEBI example from before can be represented using .. code-block:: turtle @prefix sh: . [ sh:declare [ sh:prefix "CHEBI" ; sh:namespace "http://purl.obolibrary.org/obo/CHEBI_" . ] . ] A SHACL context can be loaded from a remote file via HTTP, HTTPS, or FTP with .. code-block:: python import curies url = "https://raw.githubusercontent.com/biopragmatics/bioregistry/main/exports/contexts/semweb.context.ttl" converter = curies.load_shacl(url) A SHACL context stored in a local file can be loaded with the following. This works with both :class:`pathlib.Path` and vanilla strings. .. code-block:: python from pathlib import Path from urllib.request import urlretrieve import curies url = "https://raw.githubusercontent.com/biopragmatics/bioregistry/main/exports/contexts/semweb.context.ttl" path = Path.home().joinpath("Downloads", "semweb.context.ttl") urlretrieve(url, path) converter = curies.load_shacl(path) **************************** Introspecting on a Context **************************** After loading a context, it's possible to get certain information out of the converter. For example, if you want to get all of the CURIE prefixes from the converter, you can use :meth:`Converter.get_prefixes`: .. code-block:: python import curies converter = curies.get_bioregistry_converter() prefixes = converter.get_prefixes() assert "chebi" in prefixes assert "CHEBIID" not in prefixes, "No synonyms are included by default" prefixes = converter.get_prefixes(include_synonyms=True) assert "chebi" in prefixes assert "CHEBIID" in prefixes Similarly, the URI prefixes can be extracted with :meth:`Converter.get_uri_prefixes` like in: .. code-block:: python import curies converter = curies.get_bioregistry_converter() uri_prefixes = converter.get_uri_prefixes() assert "http://purl.obolibrary.org/obo/CHEBI_" in prefixes assert ( "https://bioregistry.io/chebi:" not in prefixes ), "No synonyms are included by default" uri_prefixes = converter.get_uri_prefixes(include_synonyms=True) assert "http://purl.obolibrary.org/obo/CHEBI_" in prefixes assert "https://bioregistry.io/chebi:" in prefixes It's also possible to get a bijective prefix map, i.e., a dictionary from primary CURIE prefixes to primary URI prefixes. This is useful for compatibility with legacy systems which assume simple prefix maps. This can be done with the ``bimap`` property like in the following: .. code-block:: python import curies converter = curies.get_bioregistry_converter() prefix_map = converter.bimap assert prefix_map["chebi"] == "http://purl.obolibrary.org/obo/CHEBI_" ********************* Modifying a Context ********************* Incremental Converters ====================== As suggested in `#13 `_, new data can be added to an existing converter with either :meth:`curies.Converter.add_prefix` or :meth:`curies.Converter.add_record`. For example, a CURIE and URI prefix for HGNC can be added to the OBO Foundry converter with the following: .. code-block:: import curies converter = curies.get_obo_converter() converter.add_prefix("hgnc", "https://bioregistry.io/hgnc:") Similarly, an empty converter can be instantiated using an empty list for the `records` argument and prefixes can be added one at a time (note this currently does not allow for adding synonyms separately): .. code-block:: import curies converter = curies.Converter(records=[]) converter.add_prefix("hgnc", "https://bioregistry.io/hgnc:") A more flexible version of this operation first involves constructing a :class:`curies.Record` object: .. code-block:: import curies converter = curies.get_obo_converter() record = curies.Record(prefix="hgnc", uri_prefix="https://bioregistry.io/hgnc:") converter.add_record(record) By default, both of these operations will fail if the new content conflicts with existing content. If desired, the ``merge`` argument can be set to true to enable merging. Further, checking for conflicts and merging can be made to be case insensitive by setting ``case_sensitive`` to false. Such a merging strategy is the basis for wholesale merging of converters, described below. Chaining and Merging ==================== This package implements a faultless chain operation :func:`curies.chain` that is configurable for case sensitivity and fully considers all synonyms. :func:`curies.chain` prioritizes based on the order given. Therefore, if two prefix maps having the same prefix but different URI prefixes are given, the first is retained. The second is retained as a synonym >>> import curies >>> c1 = curies.load_prefix_map({"GO": "http://purl.obolibrary.org/obo/GO_"}) >>> c2 = curies.load_prefix_map({"GO": "https://identifiers.org/go:"}) >>> converter = curies.chain([c1, c2]) >>> converter.expand("GO:1234567") 'http://purl.obolibrary.org/obo/GO_1234567' >>> converter.compress("http://purl.obolibrary.org/obo/GO_1234567") 'GO:1234567' >>> converter.compress("https://identifiers.org/go:1234567") 'GO:1234567' Chain is the perfect tool if you want to override parts of an existing extended prefix map. For example, if you want to use most of the Bioregistry, but you would like to specify a custom URI prefix (e.g., using Identifiers.org), you can do the following .. code-block:: python import curies overrides = curies.load_prefix_map({"pubmed": "https://identifiers.org/pubmed:"}) bioregistry_converter = curies.get_bioregistry_converter() converter = curies.chain([overrides, bioregistry_converter]) assert converter.expand("pubmed:1234") == "https://identifiers.org/pubmed:1234" Subsetting ========== A subset of a converter can be extracted using :meth:`curies.Converter.get_subconverter`. This functionality is useful for downstream applications like the following: 1. You load a comprehensive extended prefix map, e.g., from the Bioregistry using :func:`curies.get_bioregistry_converter()`. 2. You load some data that conforms to this prefix map by convention. This is often the case for semantic mappings stored in the `SSSOM format `_. 3. You extract the list of prefixes *actually* used within your data 4. You subset the detailed extended prefix map to only include prefixes relevant for your data 5. You make some kind of output of the subsetted extended prefix map to go with your data. Effectively, this is a way of reconciling data. This is especially effective when using the Bioregistry or other comprehensive extended prefix maps. Here's a concrete example of doing this (which also includes a bit of data science) to do this on the SSSOM mappings from the `Disease Ontology `_ project. >>> import curies >>> import pandas as pd >>> import itertools as itt >>> commit = "faca4fc335f9a61902b9c47a1facd52a0d3d2f8b" >>> url = f"https://raw.githubusercontent.com/mapping-commons/disease-mappings/{commit}/mappings/doid.sssom.tsv" >>> df = pd.read_csv(url, sep="\t", comment="#") >>> prefixes = { ... curies.Reference.from_curie(curie).prefix ... for column in ["subject_id", "predicate_id", "object_id"] ... for curie in df[column] ... } >>> converter = curies.get_bioregistry_converter() >>> slim_converter = converter.get_subconverter(prefixes) ******************* Writing a Context ******************* After loading and modifying a context, there are several functions for writing a context to a file: - :func:`curies.write_extended_prefix_map` - :func:`curies.write_jsonld_context` - :func:`curies.write_shacl` - :func:`curies.write_tsv` Here's a self-contained example on how this works: >>> import curies >>> converter = curies.load_prefix_map( ... { ... "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", ... } ... ) >>> curies.write_shacl(converter, "example_shacl.ttl") which outputs the following file: .. code-block:: @prefix sh: . @prefix xsd: . [ sh:declare [ sh:prefix "CHEBI" ; sh:namespace "http://purl.obolibrary.org/obo/CHEBI_"^^xsd:anyURI ] ] . ************************************************ Faultless handling of overlapping URI prefixes ************************************************ Most implementations of URI parsing iterate through the CURIE prefix/URI prefix pairs in a prefix map, check if the given URI starts with the URI prefix, then returns the CURIE prefix if does. This becomes an issue when a given URI can match multiple overlapping URI prefixes in the prefix map. For example, the ChEBI URI prefix is ``http://purl.obolibrary.org/obo/CHEBI_`` and the more generic OBO URI prefix is ``http://purl.obolibrary.org/obo/``. Therefore, it is possible that a URI could be compressed two different ways, depending on the order of iteration. :mod:`curies` addresses this by using the `trie `_ data structure, which indexes potentially overlapping strings and allows for efficient lookup of the longest matching string (e.g., the URI prefix) in the tree to a given target string (e.g., the URI). .. image:: img/trie.png :width: 200px :alt: A graphical depiction of a trie. Reused under the CC0 license from Wikipedia. This has two benefits. First, it is correct. Second, searching the trie data structure can be done in sublinear time while iterating over a prefix map can only be done in linear time. When processing a lot of data, this makes a meaningful difference! The following code demonstrates that the scenario above. It will always return the correct CURIE ``CHEBI:1`` instead of the incorrect CURIE ``OBO:CHEBI_1``, regardless of the order of the dictionary, iteration, or any other factors. >>> import curies >>> converter = curies.load_prefix_map( ... { ... "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", ... "OBO": "http://purl.obolibrary.org/obo/", ... } ... ) >>> converter.compress("http://purl.obolibrary.org/obo/CHEBI_1") 'CHEBI:1' ***************** Standardization ***************** The :class:`curies.Converter` data structure supports prefix and URI prefix synonyms. The following example demonstrates using these synonyms to support standardizing prefixes, CURIEs, and URIs. Note below, the colloquial prefix `gomf`, sometimes used to represent the subspace in the `Gene Ontology (GO) `_ corresponding to molecular functions, is upgraded to the preferred prefix, ``GO``. >>> from curies import Converter, Record >>> converter = Converter( ... [ ... Record( ... prefix="GO", ... prefix_synonyms=["gomf", "gocc", "gobp", "go", ...], ... uri_prefix="http://purl.obolibrary.org/obo/GO_", ... uri_prefix_synonyms=[ ... "http://amigo.geneontology.org/amigo/term/GO:", ... "https://identifiers.org/GO:", ... # ... ... ], ... ), ... # ... ... ] ... ) >>> converter.standardize_prefix("gomf") 'GO' >>> converter.standardize_curie("gomf:0032571") 'GO:0032571' >>> converter.standardize_uri("http://amigo.geneontology.org/amigo/term/GO:0032571") 'http://purl.obolibrary.org/obo/GO_0032571' Note: non-standard URIs (i.e., ones based on URI prefix synonyms) can still be parsed with :meth:`curies.Converter.parse_uri` and compressed into CURIEs with :meth:`curies.Converter.compress`. ***************** Bulk Operations ***************** Expansion, compression, and standardization operations can be done in bulk to all rows in a :class:`pandas.DataFrame` using the following examples. Bulk Compress URIs ================== In order to demonstrate bulk operations using :meth:`curies.Converter.pd_compress`, we construct a small dataframe: .. code-block:: python import curies import pandas as pd df = pd.DataFrame( { "uri": [ "http://purl.obolibrary.org/obo/GO_0000010", "http://purl.obolibrary.org/obo/GO_0000011", "http://gudt.org/schema/gudt/baseCGSUnitDimensions", "http://qudt.org/schema/qudt/conversionMultiplier", ] } ) converter = curies.get_obo_converter() converter.pd_compress(df, column="uri", target_column="curie") Results will look like: ================================================= ========== uri curie ================================================= ========== http://purl.obolibrary.org/obo/GO_0000010 GO:0000010 http://purl.obolibrary.org/obo/GO_0000011 GO:0000011 http://gudt.org/schema/gudt/baseCGSUnitDimensions http://qudt.org/schema/qudt/conversionMultiplier ================================================= ========== Note that some URIs are not handled by the extended prefix map inside the converter, so if you want to pass those through, use ``passthrough=True`` like in .. code-block:: python converter.pd_compress(df, column="uri", target_column="curie", passthrough=True) ================================================= ================================================= uri curie ================================================= ================================================= http://purl.obolibrary.org/obo/GO_0000010 GO:0000010 http://purl.obolibrary.org/obo/GO_0000011 GO:0000011 http://gudt.org/schema/gudt/baseCGSUnitDimensions http://gudt.org/schema/gudt/baseCGSUnitDimensions http://qudt.org/schema/qudt/conversionMultiplier http://qudt.org/schema/qudt/conversionMultiplier ================================================= ================================================= The keyword ``ambiguous=True`` can be passed if the source column can either be a CURIE or URI. Then, the semantics of compression are used from :meth:`curies.Converter.compress_or_standardize`. Bulk Expand CURIEs ================== In order to demonstrate bulk operations using :meth:`curies.Converter.pd_expand`, we construct a small dataframe used in conjunction with the OBO converter (which only includes OBO Foundry ontology URI prefix expansions): .. code-block:: python import curies import pandas as pd df = pd.DataFrame( { "curie": [ "GO:0000001", "skos:exactMatch", ] } ) converter = curies.get_obo_converter() converter.pd_expand(df, column="curie", target_column="uri") =============== ========================================= curie uri =============== ========================================= GO:0000001 http://purl.obolibrary.org/obo/GO_0000001 skos:exactMatch =============== ========================================= Note that since ``skos`` is not in the OBO Foundry extended prefix map, no results are placed in the ``uri`` column. If you wan to pass through elements that can't be expanded, you can use ``passthrough=True`` like in: .. code-block:: python converter.pd_expand(df, column="curie", target_column="uri", passthrough=True) =============== ========================================= curie uri =============== ========================================= GO:0000001 http://purl.obolibrary.org/obo/GO_0000001 skos:exactMatch skos:exactMatch =============== ========================================= Alternatively, chaining together multiple converters (such as the Bioregistry) will yield better results .. code-block:: python import curies import pandas as pd df = pd.DataFrame( { "curie": [ "GO:0000001", "skos:exactMatch", ] } ) converter = curies.chain( [ curies.get_obo_converter(), curies.get_bioregistry_converter(), ] ) converter.pd_expand(df, column="curie", target_column="uri") =============== ============================================== curie uri =============== ============================================== GO:0000001 http://purl.obolibrary.org/obo/GO_0000001 skos:exactMatch http://www.w3.org/2004/02/skos/core#exactMatch =============== ============================================== The keyword ``ambiguous=True`` can be passed if the source column can either be a CURIE or URI. Then, the semantics of compression are used from :meth:`curies.Converter.compress_or_standardize`. Bulk Standardizing Prefixes =========================== The `Gene Ontology (GO) Annotations Database `_ distributes its file where references to proteins from the `Universal Protein Resource (UniProt) `_ use the prefix ``UniProtKB``. When using the Bioregistry's extended prefix map, these prefixes should be standardized to ``uniprot`` with :meth:`curies.Converter.pd_standardize_prefix`. This can be done in-place with the following: .. code-block:: python import pandas import curies # the first column represents the prefix for the protein, # called "DB" in the schema. This is where we want to upgrade # `UniProtKB` to `uniprot` df = pd.read_csv( "http://geneontology.org/gene-associations/goa_human.gaf.gz", sep="\t", comment="!", header=None, ) converter = curies.get_bioregistry_converter() converter.pd_standardize_prefix(df, column=0) The ``target_column`` keyword can be given if you don't want to overwrite the original. Bulk Standardizing CURIEs ========================= Using the same example data from GO, the sixth column contains CURIE for references such as `GO_REF:0000043 `_. When using the Bioregistry's extended prefix map, these CURIEs' prefixes should be standardized to ``go.ref`` with :meth:`curies.Converter.pd_standardize_curie`. This can be done in-place with the following: .. code-block:: python import pandas import curies df = pd.read_csv( "http://geneontology.org/gene-associations/goa_human.gaf.gz", sep="\t", comment="!", header=None, ) converter = curies.get_bioregistry_converter() converter.pd_standardize_curie(df, column=5) The ``target_column`` keyword can be given if you don't want to overwrite the original. File Operations =============== Apply in bulk to a CSV file with :meth:`curies.Converter.file_expand` and :meth:`curies.Converter.file_compress` (defaults to using tab separator): .. code-block:: python import curies path = ... converter = curies.get_obo_converter() # modifies file in place converter.file_compress(path, column=0) # modifies file in place converter.file_expand(path, column=0) Like with the Pandas operations, the keyword ``ambiguous=True``` can be set when entries can either be CURIEs or URIs. ********************************************* Tools for Developers and Semantic Engineers ********************************************* Working with strings that might be a URI or a CURIE =================================================== Sometimes, it's not clear if a string is a CURIE or a URI. While the `SafeCURIE syntax `_ is intended to address this, it's often overlooked. CURIE and URI Checks -------------------- The first way to handle this ambiguity is to be able to check if the string is a CURIE or a URI. Therefore, each :class:`curies.Converter` comes with functions for checking if a string is a CURIE (:meth:`curies.Converter.is_curie`) or a URI (:meth:`curies.Converter.is_uri`) under its definition. .. code-block:: python import curies converter = curies.get_obo_converter() assert converter.is_curie("GO:1234567") # This is a URL assert not converter.is_curie("http://purl.obolibrary.org/obo/GO_1234567") # This is a valid CURIE, but not under this converter's definition assert not converter.is_curie("pdb:2gc4") assert converter.is_uri("http://purl.obolibrary.org/obo/GO_1234567") # This is a CURIE, but not a URI assert converter.is_uri("GO:1234567") # This is a valid URI, but not under this converter's definition assert not converter.is_uri("http://proteopedia.org/wiki/index.php/2gc4") Extended Expansion and Compression ---------------------------------- The :meth:`curies.Converter.expand_or_standardize` extends the CURIE expansion function to handle the situation where you might get passed a CURIE or a URI. If it's a CURIE, expansions happen with the normal rules. If it's a URI, it tries to standardize it. .. code-block:: python from curies import Converter, Record converter = Converter.from_extended_prefix_map( [ Record( prefix="CHEBI", prefix_synonyms=["chebi"], uri_prefix="http://purl.obolibrary.org/obo/CHEBI_", uri_prefix_synonyms=["https://identifiers.org/chebi:"], ), ] ) # Expand CURIEs assert ( converter.expand_or_standardize("CHEBI:138488") == "http://purl.obolibrary.org/obo/CHEBI_138488" ) assert ( converter.expand_or_standardize("chebi:138488") == "http://purl.obolibrary.org/obo/CHEBI_138488" ) # standardize URIs assert ( converter.expand_or_standardize("http://purl.obolibrary.org/obo/CHEBI_138488") == "http://purl.obolibrary.org/obo/CHEBI_138488" ) assert ( converter.expand_or_standardize("https://identifiers.org/chebi:138488") == "http://purl.obolibrary.org/obo/CHEBI_138488" ) # Handle cases that aren't valid w.r.t. the converter assert converter.expand_or_standardize("missing:0000000") is None assert converter.expand_or_standardize("https://example.com/missing:0000000") is None A similar workflow is implemented in :meth:`curies.Converter.compress_or_standardize` for compressing URIs where a CURIE might get passed. .. code-block:: python from curies import Converter, Record converter = Converter.from_extended_prefix_map( [ Record( prefix="CHEBI", prefix_synonyms=["chebi"], uri_prefix="http://purl.obolibrary.org/obo/CHEBI_", uri_prefix_synonyms=["https://identifiers.org/chebi:"], ), ] ) # Compress URIs assert ( converter.compress_or_standardize("http://purl.obolibrary.org/obo/CHEBI_138488") == "CHEBI:138488" ) assert ( converter.compress_or_standardize("https://identifiers.org/chebi:138488") == "CHEBI:138488" ) # standardize CURIEs assert converter.compress_or_standardize("CHEBI:138488") == "CHEBI:138488" assert converter.compress_or_standardize("chebi:138488") == "CHEBI:138488" # Handle cases that aren't valid w.r.t. the converter assert converter.compress_or_standardize("missing:0000000") is None assert converter.compress_or_standardize("https://example.com/missing:0000000") is None Reusable data structures for references ======================================= While URIs and CURIEs are often represented as strings, for many programmatic applications, it is preferable to pre-parse them into a pair of prefix corresponding to a semantic space and local unique identifier from that semantic space. ``curies`` provides two complementary data structures for representing these pairs: 1. :mod:`curies.ReferenceTuple` - a native Python :class:`typing.NamedTuple` that is storage efficient, can be hashed, can be accessed by slicing, unpacking, or via attributes. 2. :mod:`curies.Reference` - a :class:`pydantic.BaseModel` that can be used directly with other Pydantic models, FastAPI, SQLModel, and other JSON-schemata Internally, :mod:`curies.ReferenceTuple` is used, but there is a big benefit to standardizing this data type and providing utilities to flip-flop back and forth to :mod:`curies.Reference`, which is preferable in data validation (such as when parsing OBO ontologies) Integrating with :mod:`rdflib` ============================== RDFlib is a pure Python package for manipulating RDF data. The following example shows how to bind the extended prefix map from a :class:`curies.Converter` to a graph (:class:`rdflib.Graph`). .. code-block:: python import curies, rdflib converter = curies.get_obo_converter() graph = rdflib.Graph() converter.bind_rdflib(graph) A more flexible approach is to instantiate a namespace manager (:class:`rdflib.namespace.NamespaceManager`) and bind directly to that. .. code-block:: python import curies, rdflib.namespace converter = curies.get_obo_converter() namespace_manager = rdflib.namespace.NamespaceManager(rdflib.Graph()) converter.bind_rdflib(namespace_manager) URI references for use in RDFLib's graph class can be constructed from CURIEs using a combination of :meth:`curies.Converter.expand` and :class:`rdflib.URIRef`. .. code-block:: python import curies, rdflib converter = curies.get_obo_converter() uri_ref = rdflib.URIRef(converter.expand("CHEBI:138488", strict=True)) biopragmatics-curies-aa8bd37/docs/source/typing.rst000066400000000000000000000060501525104130300226100ustar00rootroot00000000000000######## Typing ######## This package comes with utilities for better typing other resources. **************** Prefix Parsing **************** Let's say you have a table like this: ====== ========== ======== ====== prefix identifier name smiles ====== ========== ======== ====== CHEBI 16236 ethanol CCO CHEBI 28831 propanol CCCO CHOBI 44884 pentanol CCCCCO ====== ========== ======== ====== Note that there's a typo in the prefix on the fourth row in the prefix because it uses ``CHOBI`` instead of ``CHEBI``. In the following code, we simulate reading that file and show where the error shows up: .. code-block:: python import csv from pydantic import BaseModel, ValidationError from curies import Converter, Prefix converter = Converter.from_prefix_map( { "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", } ) class Row(BaseModel): prefix: Prefix identifier: str name: str smiles: str records = [ {"prefix": "CHEBI", "identifier": "16236", "name": "ethanol", "smiles": "CCO"}, {"prefix": "CHEBI", "identifier": "28831", "name": "propanol", "smiles": "CCCO"}, {"prefix": "CHOBI", "identifier": "44884", "name": "pentanol", "smiles": "CCCCCO"}, ] for record in records: try: model = Row.model_validate(record, context=converter) except ValidationError as e: print(f"Issue parsing record {record}: {e}") continue Note that :meth:`pydantic.BaseModel.model_validate` allows for passing a "context". The :class:`curies.Prefix` class implements custom context handling, so if you pass a converter, it knows how to check using prefixes in the converter. *************** CURIE Parsing *************** Let's use a similar table, now with the prefix and identifier combine into CURIEs. =========== ======== ====== curie name smiles =========== ======== ====== CHEBI:16236 ethanol CCO CHEBI:28831 propanol CCCO CHOBI:44884 pentanol CCCCCO =========== ======== ====== Note that there's a typo in the prefix on the fourth row in the prefix because it uses ``CHOBI`` instead of ``CHEBI``. In the following code, we simulate reading that file and show where the error shows up: .. code-block:: python import csv from pydantic import BaseModel, ValidationError from curies import Converter, Reference converter = Converter.from_prefix_map( { "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", } ) class Row(BaseModel): curie: Reference name: str smiles: str records = [ {"curie": "CHEBI:16236", "name": "ethanol", "smiles": "CCO"}, {"curie": "CHEBI:28831", "name": "propanol", "smiles": "CCCO"}, {"curie": "CHOBI:44884", "name": "pentanol", "smiles": "CCCCCO"}, ] for record in records: try: model = Row.model_validate(record, context=converter) except ValidationError as e: print(f"Issue parsing record {record}: {e}") continue biopragmatics-curies-aa8bd37/docs/source/w3c.rst000066400000000000000000000002261525104130300217710ustar00rootroot00000000000000################ W3C Validation ################ .. automodapi:: curies.w3c :no-inheritance-diagram: :no-heading: :include-all-objects: biopragmatics-curies-aa8bd37/pyproject.toml000066400000000000000000000151611525104130300212330ustar00rootroot00000000000000[build-system] requires = ["uv_build>=0.9.6,<1.0"] build-backend = "uv_build" [project] name = "curies" version = "0.15.1" description = "Idiomatic conversion between URIs and compact URIs (CURIEs)" readme = "README.md" authors = [ { name = "Charles Tapley Hoyt", email = "cthoyt@gmail.com" } ] maintainers = [ { name = "Charles Tapley Hoyt", email = "cthoyt@gmail.com" } ] # See https://packaging.python.org/en/latest/guides/writing-pyproject-toml/#classifiers # Search tags using the controlled vocabulary at https://pypi.org/classifiers classifiers = [ "Development Status :: 5 - Production/Stable", "Environment :: Console", "Intended Audience :: Developers", "Operating System :: OS Independent", "Framework :: Pytest", "Framework :: tox", "Framework :: Sphinx", "Natural Language :: English", "Programming Language :: Python", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", "Programming Language :: Python :: 3.14", "Programming Language :: Python :: 3 :: Only", "Typing :: Typed", ] keywords = [ "snekpack", # please keep this keyword to credit the cookiecutter-snekpack template "cookiecutter", "semantic web", "compact uniform resource identifiers", "uniform resource identifiers", "curies", "IRIs", "URIs", ] # License Information. # See PEP-639 at https://peps.python.org/pep-0639/#add-license-files-key license = "MIT" license-files = ["LICENSE"] requires-python = ">=3.11" dependencies = [ "pystow>=0.9.0", "pydantic>=2.0", "typing-extensions", ] [dependency-groups] tests = [ "pytest", "coverage[toml]", "requests", "httpx", "httpx2", ] docs = [ "sphinx>=8", "sphinx-rtd-theme>=3.0", "sphinx-click", "sphinx-automodapi", "autodoc-pydantic", ] lint = [ "ruff", ] typing = [ { include-group = "tests" }, "mypy", "types-requests", "types-PyYAML", "types-ujson", "pandas-stubs", "pydantic", "bioregistry", "types-Markdown", "types-defusedxml", "types-tqdm", "httpx", "httpx2", ] docs-lint = [ { include-group = "docs" }, "doc8", ] format-docs = [ { include-group = "docs" }, "docstrfmt", ] doctests = [ "xdoctest", "pygments", ] pyroma = [ "uv-build", "pyroma", "pygments", ] [project.optional-dependencies] pandas = [ "pandas", ] sqlalchemy = [ "sqlalchemy", ] sqlmodel = [ "sqlmodel", ] flask = [ "flask", "defusedxml", ] fastapi = [ "fastapi", "python-multipart", "httpx2", "defusedxml", "uvicorn", ] rdflib = [ "rdflib" ] # See https://packaging.python.org/en/latest/guides/writing-pyproject-toml/#urls # and also https://packaging.python.org/en/latest/specifications/well-known-project-urls/ [project.urls] "Bug Tracker" = "https://github.com/biopragmatics/curies/issues" Homepage = "https://github.com/biopragmatics/curies" Repository = "https://github.com/biopragmatics/curies.git" Documentation = "https://curies.readthedocs.io" Funding = "https://github.com/sponsors/cthoyt" [project.scripts] curies = "curies.cli:main" [tool.cruft] skip = [ "**/__init__.py", "tests/*" ] # MyPy, see https://mypy.readthedocs.io/en/stable/config_file.html [tool.mypy] plugins = [ "pydantic.mypy", ] # Doc8, see https://doc8.readthedocs.io/en/stable/readme.html#ini-file-usage [tool.doc8] max-line-length = 120 # Pytest, see https://docs.pytest.org/en/stable/reference/customize.html#pyproject-toml [tool.pytest.ini_options] markers = [ "slow: marks tests as slow (deselect with '-m \"not slow\"')", ] filterwarnings = [ "ignore::pyparsing.PyparsingDeprecationWarning", ] # Coverage, see https://coverage.readthedocs.io/en/latest/config.html [tool.coverage.run] branch = true source = [ "curies", ] omit = [ "tests/*", "docs/*", "src/curies/version.py", "src/curies/__main__.py", "src/curies/cli.py", ] [tool.coverage.paths] source = [ "src/curies", ".tox/*/lib/python*/site-packages/curies", ] [tool.coverage.report] show_missing = true exclude_lines = [ "pragma: no cover", "raise NotImplementedError", "if __name__ == \"__main__\":", "if TYPE_CHECKING:", "def __str__", "def __repr__", ] [tool.ruff] line-length = 100 extend-include = ["*.ipynb"] [tool.ruff.lint] # See https://docs.astral.sh/ruff/rules extend-select = [ "F", # pyflakes "E", # pycodestyle errors "W", # pycodestyle warnings "C90", # mccabe "I", # isort "UP", # pyupgrade "D", # pydocstyle "DOC", # pydoclint "B", # bugbear "S", # bandit "T20", # print "N", # pep8 naming "ERA", # eradicate commented out code "NPY", # numpy checks "RUF", # ruff rules "C4", # comprehensions ] ignore = [ "D105", # Missing docstring in magic method "E203", # Black conflicts with the following "ERA001", # TODO remove "E501", # TODO remove "N818", # TODO remove "C901", # TODO remove? "DTZ011", ] # See https://docs.astral.sh/ruff/settings/#per-file-ignores [tool.ruff.lint.per-file-ignores] # Ignore security issues in the version.py, which are inconsistent "src/curies/version.py" = ["S603", "S607"] # Ignore commented out code in Sphinx configuration file "docs/source/conf.py" = ["ERA001"] # Prints are okay in notebooks "notebooks/**/*.ipynb" = ["T201"] [tool.ruff.lint.pydocstyle] convention = "pep257" [tool.ruff.lint.isort] relative-imports-order = "closest-to-furthest" known-third-party = [ "tqdm", ] known-first-party = [ "curies", "tests", ] [tool.ruff.format] # see https://docs.astral.sh/ruff/settings/#format_docstring-code-format docstring-code-format = true [tool.bumpversion] current_version = "0.15.1" parse = "(?P\\d+)\\.(?P\\d+)\\.(?P\\d+)(?:-(?P[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?(?:\\+(?P[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?" serialize = [ "{major}.{minor}.{patch}-{release}+{build}", "{major}.{minor}.{patch}+{build}", "{major}.{minor}.{patch}-{release}", "{major}.{minor}.{patch}", ] commit = true tag = false [tool.bumpversion.parts.release] optional_value = "production" first_value = "dev" values = [ "dev", "production", ] [[tool.bumpversion.files]] filename = "pyproject.toml" search = "version = \"{current_version}\"" replace = "version = \"{new_version}\"" [[tool.bumpversion.files]] filename = "docs/source/conf.py" search = "release = \"{current_version}\"" replace = "release = \"{new_version}\"" [[tool.bumpversion.files]] filename = "src/curies/version.py" search = "VERSION = \"{current_version}\"" replace = "VERSION = \"{new_version}\"" biopragmatics-curies-aa8bd37/src/000077500000000000000000000000001525104130300171025ustar00rootroot00000000000000biopragmatics-curies-aa8bd37/src/curies/000077500000000000000000000000001525104130300203745ustar00rootroot00000000000000biopragmatics-curies-aa8bd37/src/curies/__init__.py000066400000000000000000000043521525104130300225110ustar00rootroot00000000000000"""Idiomatic conversion between URIs and compact URIs (CURIEs).""" from .api import ( Converter, DuplicatePrefixes, DuplicateURIPrefixes, DuplicateValueError, NamableReference, NamedReference, Prefix, PrefixMap, Record, Records, Reference, ReferenceTuple, chain, load_extended_prefix_map, load_jsonld_context, load_prefix_map, load_shacl, upgrade_prefix_map, write_extended_prefix_map, write_jsonld_context, write_shacl, write_tsv, ) from .dataframe import filter_df_by_curies, filter_df_by_prefixes from .discovery import discover, discover_from_rdf from .mixins import SemanticallyProcessable, SemanticallyStandardizable, process, standardize from .preprocessing import ( PostprocessingRewrites, PreprocessingBlocklists, PreprocessingConverter, PreprocessingRewrites, PreprocessingRules, ) from .reconciliation import remap_curie_prefixes, remap_uri_prefixes, rewire from .sources import ( get_bioregistry_converter, get_go_converter, get_monarch_converter, get_obo_converter, get_prefixcommons_converter, ) from .triples import Triple from .version import get_version __all__ = [ "Converter", "DuplicatePrefixes", "DuplicateURIPrefixes", "DuplicateValueError", "NamableReference", "NamedReference", "PostprocessingRewrites", "Prefix", "PrefixMap", "PreprocessingBlocklists", "PreprocessingConverter", "PreprocessingRewrites", "PreprocessingRules", "Record", "Records", "Reference", "ReferenceTuple", "SemanticallyProcessable", "SemanticallyStandardizable", "Triple", "chain", "discover", "discover_from_rdf", "filter_df_by_curies", "filter_df_by_prefixes", "get_bioregistry_converter", "get_go_converter", "get_monarch_converter", "get_obo_converter", "get_prefixcommons_converter", "get_version", "load_extended_prefix_map", "load_jsonld_context", "load_prefix_map", "load_shacl", "process", "remap_curie_prefixes", "remap_uri_prefixes", "rewire", "standardize", "upgrade_prefix_map", "write_extended_prefix_map", "write_jsonld_context", "write_shacl", "write_tsv", ] biopragmatics-curies-aa8bd37/src/curies/__main__.py000066400000000000000000000001531525104130300224650ustar00rootroot00000000000000"""Command line interface for ``curies``.""" from .cli import main if __name__ == "__main__": main() biopragmatics-curies-aa8bd37/src/curies/api.py000066400000000000000000003701641525104130300215320ustar00rootroot00000000000000"""Data structures and algorithms for :mod:`curies`.""" from __future__ import annotations import csv import itertools as itt import json import logging from collections import UserDict, defaultdict from collections.abc import Callable, Collection, Iterable, Iterator, Mapping, Sequence from functools import partial from pathlib import Path from textwrap import dedent from typing import ( TYPE_CHECKING, Annotated, Any, Literal, NamedTuple, Self, TypeAlias, TypeVar, Union, cast, overload, ) from pydantic import ( AfterValidator, AnyUrl, BaseModel, ConfigDict, Field, GetCoreSchemaHandler, RootModel, field_validator, model_validator, ) from pydantic_core import core_schema from .utils import NoCURIEDelimiterError, _split if TYPE_CHECKING: # pragma: no cover import httpx import httpx2 import pandas import rdflib from .triples import Triple __all__ = [ "Converter", "DuplicatePrefixes", "DuplicateURIPrefixes", "DuplicateValueError", "NamableReference", "NamedReference", "NoCURIEDelimiterError", "Prefix", "PrefixMap", "Record", "Records", "Reference", "ReferenceTuple", "Trie", "TrieNode", "chain", "load_extended_prefix_map", "load_jsonld_context", "load_prefix_map", "load_shacl", "upgrade_prefix_map", "write_extended_prefix_map", "write_jsonld_context", "write_shacl", "write_tsv", ] logger = logging.getLogger(__name__) X = TypeVar("X") LocationOr: TypeAlias = str | Path | X #: A hint for a URI, must include a str() method that does the expected thing URIType: TypeAlias = Union[str, AnyUrl, "rdflib.URIRef", "httpx.URL", "httpx2.URL"] def _get_field_validator_values(values: Any, key: str) -> str: """Get the value for the key from a field validator object.""" return cast(str, values.data[key]) class ReferenceTuple(NamedTuple): """A pair of a prefix (corresponding to a semantic space) and a local unique identifier in that semantic space. This class derives from the "named tuple" which means that it acts like a tuple in most senses - it can be hashed and unpacked like most other tuples. Underneath, it has a C implementation and is very efficient. A reference tuple can be constructed two ways: >>> ReferenceTuple("chebi", "1234") ReferenceTuple(prefix='chebi', identifier='1234') >>> ReferenceTuple.from_curie("chebi:1234") ReferenceTuple(prefix='chebi', identifier='1234') A reference tuple can be formatted as a CURIE string with the ``curie`` attribute >>> ReferenceTuple.from_curie("chebi:1234").curie 'chebi:1234' Reference tuples can be sliced like regular 2-tuples >>> t = ReferenceTuple.from_curie("chebi:1234") >>> t[0] 'chebi' >>> t[1] '1234' Similarly, reference tuples can be unpacked like regular 2-tuples >>> prefix, identifier = ReferenceTuple.from_curie("chebi:1234") >>> prefix 'chebi' >>> identifier '1234' Because they are named tuples, reference tuples can be accessed with attributes >>> t = ReferenceTuple.from_curie("chebi:1234") >>> t.prefix 'chebi' >>> t.identifier '1234' """ prefix: str identifier: str @property def curie(self) -> str: """Get the reference as a CURIE string. :returns: A string representation of a compact URI (CURIE). >>> ReferenceTuple("chebi", "1234").curie 'chebi:1234' """ return f"{self.prefix}:{self.identifier}" @classmethod def from_curie(cls, curie: str, *, sep: str = ":") -> Self: """Parse a CURIE string and populate a reference tuple. :param curie: A string representation of a compact URI (CURIE) :param sep: The separator :returns: A reference tuple >>> ReferenceTuple.from_curie("chebi:1234") ReferenceTuple(prefix='chebi', identifier='1234') """ prefix, identifier = _split(curie, sep=sep) return cls(prefix, identifier) # docstr-coverage:excused `overload` @overload def to_pydantic(self, *, name: str = ...) -> NamedReference: ... # docstr-coverage:excused `overload` @overload def to_pydantic(self, *, name: None = ...) -> Reference: ... def to_pydantic(self, *, name: str | None = None) -> Reference | NamedReference: """Get a Pydantic model.""" if name is None: return Reference(prefix=Prefix(self.prefix), identifier=self.identifier) if not name: raise ValueError( f"tried to construct a pydantic named reference with a missing name from {self.curie}" ) return NamedReference(prefix=Prefix(self.prefix), identifier=self.identifier, name=name) class Prefix(str): """A string that is validated by Pydantic as a CURIE prefix. This class is a subclass of Python's built-in string class, so you can wrap any string with it: .. code-block:: python from curies import Prefix prefix = Prefix("CHEBI") You can implicitly type annotate data with this class: .. code-block:: python from curies import Prefix prefix_map: dict[Prefix, str] = { "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", } You can more explicitly type annotate data with this class using Pydantic's `root model `_: .. code-block:: python from pydantic import RootModel from curies import Prefix PrefixMap = RootModel[dict[Prefix, str]] prefix_map = PrefixMap.model_validate( { "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", } ).root This pattern is common enough that it's included in :class:`curies.PrefixMap`. When used inside a Pydantic model, this class knows how to do validation that the prefix matches the regular expression for an XSD NCName. Here's an example usage with Pydantic: .. code-block:: python from curies import Prefix from pydantic import BaseModel class ResourceInfo(BaseModel): prefix: Prefix name: str model = ResourceInfo.model_validate( { "prefix": "CHEBI", "name": "Chemical Entities of Biological Interest", } ) # raises a pydantic.ValidationError, because the prefix # doesn't match the NCName pattern ResourceInfo.model_validate( { "prefix": "$nope", "name": "An invalid semantic space!", } ) This class implements a hook that uses Pydantic's "context" for validation that lets you pass a :class:`Converter` to check for existence and standardization with respect to the context in the converter: .. code-block:: python from curies import Prefix, get_obo_converter from pydantic import BaseModel class ResourceInfo(BaseModel): prefix: Prefix name: str converter = get_obo_converter() model = ResourceInfo.model_validate( { "prefix": "CHEBI", "name": "Chemical Entities of Biological Interest", }, context=converter, ) # raises a pydantic.ValidationError, because the prefix # is not registered in the OBO Foundry, and is therefore # not part of the OBO converter ResourceInfo.model_validate( { "prefix": "efo", "name": "Experimental Factor Ontology", }, context=converter, ) # In case you need to pass more arbitrary # context, you can also use a dict with the key # "converter" ResourceInfo.model_validate( { "prefix": "CHEBI", "name": "Chemical Entities of Biological Interest", }, context={ "converter": converter, }, ) .. warning:: Serialization with YAML with :mod:`yaml` might not work as expected for classes containing :class:`Prefix` instances, since they are subclasses of strings. Do something like this: .. code-block:: python def _reference_representer( dumper: SafeRepresenter, data: curies.Prefix ) -> yaml.ScalarNode: return dumper.represent_str(str(data)) # if you're using yaml.safe_dump() yaml.add_representer(curies.Prefix, _reference_representer, Dumper=yaml.SafeDumper) # if you're using yaml.dump() yaml.add_representer(curies.Prefix, _reference_representer, Dumper=yaml.Dumper) """ @classmethod def __get_pydantic_core_schema__( cls, source: type[Any], handler: GetCoreSchemaHandler ) -> core_schema.AfterValidatorFunctionSchema: return core_schema.with_info_after_validator_function( cls._validate, # TODO consider if we should use strict NCNAME pattern # here like ^$|^[a-zA-Z_][\w.-]*$. See also # https://cthoyt.com/2023/01/11/bioregistry-w3c-compliance.html core_schema.str_schema(strict=False), ) @classmethod def _validate(cls, /, __input_value: str, info: core_schema.ValidationInfo) -> Self: converter = _converter_from_validation_info(info) if converter is None: return cls(__input_value) return cls(converter.standardize_prefix(__input_value, strict=True)) class PrefixMap(RootModel[dict[Prefix, str]]): """A simple prefix map. This can be used to validate dictionaries: .. code-block:: python from curies import PrefixMap prefix_map_model = PrefixMap.model_validate( { "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", } ) # note that you have to unpack it prefix_map_dict = prefix_map_model.root Similarly, a prefix map can be used as part of another Pydantic model like in: .. code-block:: python from pydantic import BaseModel from curies import PrefixMap class RDFContent(BaseModel): prefix_map: PrefixMap triples: list[tuple[str, str, str]] rdf_content = RDFContent.model_validate( { "prefix_map": { "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", }, "triples": [ ("CHEBI:1234", "RO:0000001", "CHEBI:5678"), ], } ) # note that you have to unpack the resulting prefix map prefix_map = rdf_content.prefix_map.root """ class MalformedIdentifierError(ValueError): """Raise for malformed local unique identifiers.""" def _validate_identifier(s: str) -> str: if " " in s: raise MalformedIdentifierError(f"local identifiers can not contain spaces: {s}") return s class Reference(BaseModel): """A reference to an entity in a given identifier space. This class uses Pydantic to make it easier to build other more complex data types with Pydantic that also uses a first- class notion of parsed reference (instead of merely stringified CURIEs). Instances of this class can also be hashed because of the "frozen" configuration from Pydantic (see https://docs.pydantic.dev/latest/usage/model_config/ for more details). A reference can be constructed several ways: >>> Reference(prefix="chebi", identifier="1234") Reference(prefix='chebi', identifier='1234') >>> Reference.from_curie("chebi:1234") Reference(prefix='chebi', identifier='1234') A reference can also be constructued using Pydantic's parsing utilities, but keep in mind if you're using Pydantic v1 or Pydantic v2. A reference can be formatted as a CURIE string with the ``curie`` attribute >>> Reference.from_curie("chebi:1234").curie 'chebi:1234' References can't be sliced like reference tuples, but they can still be accessed through attributes >>> t = Reference.from_curie("chebi:1234") >>> t.prefix 'chebi' >>> t.identifier '1234' If you need a performance gain, you can get a :class:`ReferenceTuple` using the ``pair`` attribute: >>> reference = Reference.from_curie("chebi:1234") >>> reference.pair ReferenceTuple(prefix='chebi', identifier='1234') """ prefix: Annotated[ Prefix, Field( description="The prefix used in a compact URI (CURIE).", ), ] identifier: Annotated[ str, AfterValidator(_validate_identifier), Field(description="The local unique identifier used in a compact URI (CURIE)."), ] model_config = ConfigDict(frozen=True) @model_validator(mode="before") def _parse_from_string(cls, values: str | dict[str, str]) -> dict[str, str]: # noqa:N805 if isinstance(values, str): prefix, identifier = _split(values) return {"prefix": prefix, "identifier": identifier} return values def __lt__(self, other: Reference) -> bool: """Sort the reference lexically first by prefix, then by identifier.""" return self.pair < other.pair def __hash__(self) -> int: return hash((self.prefix, self.identifier)) def __eq__(self, other: object) -> bool: return ( isinstance(other, Reference) and self.prefix == other.prefix and self.identifier == other.identifier ) def __composite_values__(self) -> tuple[str, str]: """Return values appropriate for :func:`sqlalchemy.orm.composite`.""" return self.prefix, self.identifier @property def curie(self) -> str: """Get the reference as a CURIE string. :returns: A string representation of a compact URI (CURIE). >>> Reference(prefix="chebi", identifier="1234").curie 'chebi:1234' """ return f"{self.prefix}:{self.identifier}" @property def pair(self) -> ReferenceTuple: """Get the reference as a 2-tuple of prefix and identifier.""" return ReferenceTuple(self.prefix, self.identifier) # note that it's important that this is explicitly # Reference and not Self, since all subclasses should # return only a reference. def without_name(self) -> Reference: """Return this reference, since it already has no name.""" return self def with_name(self, name: str) -> NamableReference: """Return this reference, with a name.""" return NamedReference(prefix=self.prefix, identifier=self.identifier, name=name) @classmethod def from_curie(cls, curie: str, *, sep: str = ":", converter: Converter | None = None) -> Self: """Parse a CURIE string and populate a reference. :param curie: A string representation of a compact URI (CURIE) :param sep: The separator :param converter: The converter to use as context when parsing :returns: A reference object >>> Reference.from_curie("chebi:1234") Reference(prefix='chebi', identifier='1234') """ prefix, identifier = _split(curie, sep=sep) return cls.model_validate({"prefix": prefix, "identifier": identifier}, context=converter) @classmethod def from_reference( cls, reference: Reference | ReferenceTuple, *, converter: Converter | None = None ) -> Self: """Parse a CURIE string and populate a reference. :param reference: A pre-parsed reference :param converter: The converter to use as context when parsing :returns: A reference object """ return cls.model_validate( {"prefix": reference.prefix, "identifier": reference.identifier}, context=converter ) class NamableReference(Reference): """A reference, maybe with a name.""" name: Annotated[ str | None, Field( description="The name of the entity referenced by this object's prefix and identifier, if exists.", ), ] = None model_config = ConfigDict(frozen=True) @classmethod def from_curie( cls, curie: str, name: str | None = None, *, sep: str = ":", converter: Converter | None = None, ) -> Self: """Parse a CURIE string and populate a reference. :param curie: A string representation of a compact URI (CURIE) :param name: The optional name of the reference :param sep: The separator :param converter: The converter to use as context when parsing :returns: A reference object >>> NamableReference.from_curie("chebi:1234") NamableReference(prefix='chebi', identifier='1234', name=None) >>> NamableReference.from_curie("chebi:1234", "6-methoxy-2-octaprenyl-1,4-benzoquinone") NamableReference(prefix='chebi', identifier='1234', name='6-methoxy-2-octaprenyl-1,4-benzoquinone') """ prefix, identifier = _split(curie, sep=sep) return cls.model_validate( {"prefix": prefix, "identifier": identifier, "name": name}, context=converter ) @classmethod def from_reference( cls, reference: Reference | ReferenceTuple, *, converter: Converter | None = None ) -> Self: """Parse a CURIE string and populate a reference. :param reference: A pre-parsed reference :param converter: The converter to use as context when parsing :returns: A reference object """ return cls.model_validate( { "prefix": reference.prefix, "identifier": reference.identifier, "name": getattr(reference, "name", None), }, context=converter, ) def without_name(self) -> Reference: """Return this reference without a name.""" return Reference(prefix=self.prefix, identifier=self.identifier) def with_name(self, name: str) -> Self: """Return this reference, with a name.""" return self.model_copy(update={"name": name}) class NamedReference(NamableReference): """A reference with a name.""" name: Annotated[ str, Field( description="The name of the entity referenced by this object's prefix and identifier." ), ] model_config = ConfigDict(frozen=True) @classmethod def from_curie( # type:ignore cls, curie: str, name: str, *, sep: str = ":", converter: Converter | None = None ) -> Self: """Parse a CURIE string and populate a reference. :param curie: A string representation of a compact URI (CURIE) :param name: The name of the reference :param sep: The separator :param converter: The converter to use as context when parsing :returns: A reference object >>> NamedReference.from_curie("chebi:1234", "6-methoxy-2-octaprenyl-1,4-benzoquinone") NamedReference(prefix='chebi', identifier='1234', name='6-methoxy-2-octaprenyl-1,4-benzoquinone') """ prefix, identifier = _split(curie, sep=sep) return cls.model_validate( {"prefix": prefix, "identifier": identifier, "name": name}, context=converter ) @classmethod def from_reference( cls, reference: Reference | ReferenceTuple, *, converter: Converter | None = None ) -> Self: """Parse a CURIE string and populate a reference. :param reference: A pre-parsed reference :param converter: The converter to use as context when parsing :returns: A reference object :raises TypeError: if a reference that has no name field is passed (e.g., a vanilla :class:`curies.Reference`) """ if not isinstance(reference, NamableReference): raise TypeError( f"tried to construct a named reference from a non-named reference: {reference}" ) return cls.model_validate( { "prefix": reference.prefix, "identifier": reference.identifier, "name": reference.name, }, context=converter, ) def with_name(self, name: str) -> Self: """Return this reference, with a name.""" return self.model_copy(update={"name": name}) RecordKey = tuple[str, str, str, str] class Record(BaseModel): """A record of some prefixes and their associated URI prefixes. .. seealso:: https://github.com/cthoyt/curies/issues/70 """ prefix: Annotated[ str, Field( title="CURIE prefix", description="The canonical CURIE prefix, used in the reverse prefix map", ), ] uri_prefix: Annotated[ str, Field( title="URI prefix", description="The canonical URI prefix, used in the forward prefix map", ), ] prefix_synonyms: list[str] = Field(default_factory=list, title="CURIE prefix synonyms") uri_prefix_synonyms: list[str] = Field(default_factory=list, title="URI prefix synonyms") pattern: Annotated[ str | None, Field( description="The regular expression pattern for entries in this semantic space. " "Warning: this is an experimental feature.", ), ] = None @field_validator("prefix_synonyms") # type:ignore @classmethod def prefix_not_in_synonyms(cls, v: str, values: Mapping[str, Any]) -> str: """Check that the canonical prefix does not apper in the prefix synonym list.""" prefix = _get_field_validator_values(values, "prefix") if prefix in v: raise ValueError(f"Duplicate of canonical prefix `{prefix}` in prefix synonyms") return v @field_validator("uri_prefix_synonyms") # type:ignore @classmethod def uri_prefix_not_in_synonyms(cls, v: str, values: Mapping[str, Any]) -> str: """Check that the canonical URI prefix does not apper in the URI prefix synonym list.""" uri_prefix = _get_field_validator_values(values, "uri_prefix") if uri_prefix in v: raise ValueError( f"Duplicate of canonical URI prefix `{uri_prefix}` in URI prefix synonyms" ) return v @property def _all_prefixes(self) -> list[str]: return [self.prefix, *self.prefix_synonyms] @property def _all_uri_prefixes(self) -> list[str]: return [self.uri_prefix, *self.uri_prefix_synonyms] @property def _key(self) -> RecordKey: """Get a hashable key.""" return ( self.prefix, self.uri_prefix, ",".join(sorted(self.prefix_synonyms)), ",".join(sorted(self.uri_prefix_synonyms)), ) # An explanation of RootModels in Pydantic V2 can be found on # https://docs.pydantic.dev/latest/concepts/models/#rootmodel-and-custom-root-types class Records(RootModel[list[Record]]): """A list of records.""" def __iter__(self) -> Iterator[Record]: # type:ignore[override] """Iterate over records.""" return iter(self.root) class DuplicateSummary(NamedTuple): """A triple representing two records that are duplicated, either based on a CURIE or URI prefix.""" record_1: Record record_2: Record prefix: str class DuplicateValueError(ValueError): """An error raised with constructing a converter with data containing duplicate values.""" def __init__(self, duplicates: list[DuplicateSummary]) -> None: """Initialize the error.""" self.duplicates = duplicates def _str(self) -> str: rv = "" for duplicate in self.duplicates: rv += f"\n{duplicate.prefix}:\n\t{duplicate.record_1}\n\t{duplicate.record_2}\n" return rv class DuplicateURIPrefixes(DuplicateValueError): """An error raised with constructing a converter with data containing duplicate URI prefixes.""" def __str__(self) -> str: return f"Duplicate URI prefixes:\n{self._str()}" class DuplicatePrefixes(DuplicateValueError): """An error raised with constructing a converter with data containing duplicate prefixes.""" def __str__(self) -> str: return f"Duplicate prefixes:\n{self._str()}" class ConversionError(ValueError): """An error raised on conversion.""" class ExpansionError(ConversionError): """An error raised on expansion if the prefix can't be looked up.""" class CompressionError(ConversionError): """An error raised on expansion if the URI prefix can't be matched.""" class StandardizationError(ValueError): """An error raised on standardization.""" class PrefixStandardizationError(StandardizationError): """An error raise when a prefix can't be standardized.""" class IdentifierStandardizationError(StandardizationError): """An error raise when an identifier can't be standardized.""" class CURIEStandardizationError(StandardizationError): """An error raise when a CURIE can't be standardized.""" class URIStandardizationError(StandardizationError): """An error raise when a URI can't be standardized.""" def _get_duplicate_uri_prefixes(records: list[Record]) -> list[DuplicateSummary]: return [ DuplicateSummary(record_1, record_2, uri_prefix) for record_1, record_2 in itt.combinations(records, 2) for uri_prefix, up2 in itt.product(record_1._all_uri_prefixes, record_2._all_uri_prefixes) if uri_prefix == up2 ] def _get_duplicate_prefixes(records: list[Record]) -> list[DuplicateSummary]: return [ DuplicateSummary(record_1, record_2, prefix) for record_1, record_2 in itt.combinations(records, 2) for prefix, p2 in itt.product(record_1._all_prefixes, record_2._all_prefixes) if prefix == p2 ] def _prepare(data: LocationOr[X]) -> X: if isinstance(data, Path): with data.open() as file: return cast(X, json.load(file)) elif isinstance(data, str): if any(data.startswith(p) for p in ("https://", "http://", "ftp://")): return cast(X, _get_remote_json(data)) with open(data) as file: return cast(X, json.load(file)) else: return data def _get_remote_json(url: str, timeout: int = 15) -> Any: import urllib.request with urllib.request.urlopen(url, timeout=timeout) as response: # noqa:S310 json_str_data = response.read().decode() return json.loads(json_str_data) class Converter: """A cached prefix map data structure. .. code-block:: # Construct a prefix map: >>> converter = Converter.from_prefix_map( ... { ... "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", ... "MONDO": "http://purl.obolibrary.org/obo/MONDO_", ... "GO": "http://purl.obolibrary.org/obo/GO_", ... "OBO": "http://purl.obolibrary.org/obo/", ... } ... ) # Compression and Expansion: >>> converter.compress("http://purl.obolibrary.org/obo/CHEBI_1") 'CHEBI:1' >>> converter.expand("CHEBI:1") 'http://purl.obolibrary.org/obo/CHEBI_1' # Example with unparsable URI: >>> converter.compress("http://example.com/missing:0000000") # Example with missing prefix: >>> converter.expand("missing:0000000") """ #: A prefix trie for efficient parsing of URIs trie: Trie #: A mapping from prefix to regular expression pattern. Not necessarily complete wrt the prefix map. #: #: .. warning:: patterns are an experimental feature pattern_map: dict[str, str] #: The list of records. Don't modify this directly records: list[Record] def __init__( self, records: Iterable[Record] | None = None, *, delimiter: str = ":", strict: bool = True ) -> None: """Instantiate a converter. :param records: A list of records. If you plan to build a converter incrementally, pass an empty list or leave this blank. :param strict: If true, raises issues on duplicate URI prefixes :param delimiter: The delimiter used for CURIEs. Defaults to a colon. :raises DuplicatePrefixes: if any records share any synonyms :raises DuplicateURIPrefixes: if any records share any URI prefixes """ if records is None: records = [] records = sorted(records, key=lambda r: r.prefix) if strict: duplicate_uri_prefixes = _get_duplicate_uri_prefixes(records) if duplicate_uri_prefixes: raise DuplicateURIPrefixes(duplicate_uri_prefixes) duplicate_prefixes = _get_duplicate_prefixes(records) if duplicate_prefixes: raise DuplicatePrefixes(duplicate_prefixes) self.delimiter = delimiter self.records = records self._prefix_to_record: dict[str, Record] = {} self._prefix_ci_to_record: dict[str, Record] = {} self._uri_prefix_to_record: dict[str, Record] = {} self._uri_prefix_ci_to_record: dict[str, Record] = {} self.trie = Trie() self.pattern_map = {} for record in records: self._index(record) @property def prefix_map(self) -> Mapping[str, str]: """Get the non-URI-prefix-unique prefix map..""" return { prefix: record.uri_prefix for record in self.records for prefix in record._all_prefixes } @property def reverse_prefix_map(self) -> Mapping[str, str]: """Get the non-URI-prefix-unique prefix map.""" return { uri_prefix: record.prefix for record in self.records for uri_prefix in record._all_uri_prefixes } def __len__(self) -> int: """Count the number of records.""" return len(self.records) def __iter__(self) -> Iterator[Record]: """Iterate over records.""" return iter(self.records) @property def bimap(self) -> Mapping[str, str]: """Get the bijective mapping between CURIE prefixes and URI prefixes.""" return {r.prefix: r.uri_prefix for r in self.records} @property def reverse_bimap(self) -> Mapping[str, str]: """Get the bijective mapping between URI CURIE prefixes and CURIE prefixes.""" return {r.uri_prefix: r.prefix for r in self.records} def has_prefix(self, prefix: str) -> bool: """Check if the converter has the prefix (either as a primary or secondary).""" return prefix in self._prefix_to_record def _match_record( self, external: Record, case_sensitive: bool = True ) -> Mapping[str, list[str]]: """Match the given record to existing records.""" rv: defaultdict[str, list[str]] = defaultdict(list) if case_sensitive: if record := self._prefix_to_record.get(external.prefix): rv[record.prefix].append( f"primary prefix ({external.prefix}) match to {self._label(external.prefix == record.prefix)} prefix for {record.prefix}" ) for prefix in external.prefix_synonyms: if record := self._prefix_to_record.get(prefix): rv[record.prefix].append( f"secondary prefix ({prefix}) matched {self._label(prefix == record.prefix)} prefix for {record.prefix}" ) if record := self._uri_prefix_to_record.get(external.uri_prefix): rv[record.prefix].append( f"primary URI prefix ({external.uri_prefix}) matched {self._label(record.uri_prefix == external.uri_prefix)} URI prefix for {record.prefix}" ) for uri_prefix in external.uri_prefix_synonyms: if record := self._uri_prefix_to_record.get(uri_prefix): rv[record.prefix].append( f"secondary URI prefix ({uri_prefix}) matched {self._label(record.uri_prefix == uri_prefix)} URI prefix for {record.prefix}" ) else: for prefix in external._all_prefixes: if record := self._prefix_ci_to_record.get(prefix.casefold()): rv[record.prefix].append("prefix case-insenstive match") for uri_prefix in external._all_uri_prefixes: if record := self._uri_prefix_ci_to_record.get(uri_prefix.casefold()): rv[record.prefix].append("URI case-insenstive prefix match") return dict(rv) @staticmethod def _label(x: bool) -> str: return "primary" if x else "secondary" def add_record( self, record: Record, *, case_sensitive: bool = True, merge: bool = False ) -> None: """Append a record to the converter.""" matched = self._match_record(record, case_sensitive=case_sensitive) if len(matched) > 1: msg = "".join(f"\n {m} -> {v}" for m, v in matched.items()) raise ValueError(f"new record has duplicates:{msg}") if len(matched) == 1: prefix, values = next(iter(matched.items())) if not merge: msg = "\n".join(f"- {v}" for v in values) raise ValueError( f"failed to add {record.prefix} because of overlaps. Full record:\n\n{record.model_dump_json(indent=2)}\n\nExplanation:\n{msg}\n" ) existing_record = self._prefix_to_record[prefix] self._merge(record, into=existing_record) self._index(existing_record) else: # Append a new record self.records.append(record) self._index(record) @staticmethod def _merge(record: Record, into: Record) -> None: xx = set(into._all_prefixes) for prefix in record._all_prefixes: if prefix not in xx: into.prefix_synonyms.append(prefix) into.prefix_synonyms.sort() yy = set(into._all_uri_prefixes) for uri_prefix in record._all_uri_prefixes: if uri_prefix not in yy: into.uri_prefix_synonyms.append(uri_prefix) into.uri_prefix_synonyms.sort() def _index(self, record: Record) -> None: for prefix in record._all_prefixes: self._index_prefix(prefix, record) for uri_prefix in record._all_uri_prefixes: self._index_uri_prefix(uri_prefix, record) if record.pattern and record.prefix not in self.pattern_map: self.pattern_map[record.prefix] = record.pattern def _index_prefix(self, prefix: str, record: Record) -> None: self._prefix_to_record[prefix] = record self._prefix_ci_to_record[prefix.casefold()] = record def _index_uri_prefix(self, uri_prefix: str, record: Record) -> None: self._uri_prefix_to_record[uri_prefix] = record self._uri_prefix_ci_to_record[uri_prefix.casefold()] = record self.trie[uri_prefix] = record def add_prefix_synonym( self, prefix: str, prefix_synonym: str, *, case_sensitive: bool = True ) -> None: """Add a prefix synonym to the record with the given prefix.""" if not case_sensitive: raise NotImplementedError try: record = self._prefix_to_record[prefix] except KeyError as e: raise KeyError( f"can not add prefix synoynm {prefix_synonym} to prefix {prefix} since {prefix} is not already indexed" ) from e sr = self._prefix_to_record.get(prefix_synonym) if sr is not None: if sr.prefix != record.prefix: raise ValueError(f"this prefix synonym is already taken by record for {sr.prefix}") return self._index_prefix(prefix_synonym, record) record.prefix_synonyms.append(prefix_synonym) record.prefix_synonyms.sort() def add_uri_prefix_synonym( self, prefix: str, uri_prefix_synonym: str, *, case_sensitive: bool = True ) -> None: """Add a URI synonym to the record with the given prefix.""" if not case_sensitive: raise NotImplementedError try: record = self._prefix_to_record[prefix] except KeyError as e: raise KeyError( f"can't add URI prefix synoynm {uri_prefix_synonym} to prefix {prefix} because " f"{prefix} is not already indexed" ) from e sr = self._uri_prefix_to_record.get(uri_prefix_synonym) if sr is not None: if sr.prefix != record.prefix: raise ValueError( f"can't add URI prefix synonym {uri_prefix_synonym} to {prefix} becauase " f"it is already taken by record for {sr.prefix}" ) return self._index_uri_prefix(uri_prefix_synonym, record) record.uri_prefix_synonyms.append(uri_prefix_synonym) record.uri_prefix_synonyms.sort() def add_prefix( self, prefix: str, uri_prefix: str, prefix_synonyms: Collection[str] | None = None, uri_prefix_synonyms: Collection[str] | None = None, *, pattern: str | None = None, case_sensitive: bool = True, merge: bool = False, ) -> None: """Append a prefix to the converter. :param prefix: The prefix to append, e.g., ``go`` :param uri_prefix: The URI prefix to append, e.g., ``http://purl.obolibrary.org/obo/GO_`` :param prefix_synonyms: An optional collection of synonyms for the prefix such as ``gomf``, ``gocc``, etc. :param uri_prefix_synonyms: An optional collections of synonyms for the URI prefix such as ``https://bioregistry.io/go:``, ``http://www.informatics.jax.org/searches/GO.cgi?id=GO:``, etc. :param pattern: An optional pattern :param case_sensitive: Should prefixes and URI prefixes be compared in a case-sensitive manner when checking for uniqueness? Defaults to True. :param merge: Should this record be merged into an existing record if it uniquely maps to a single existing record? When false, will raise an error if one or more existing records can be mapped. Defaults to false. This can be used to add missing namespaces on-the-fly to an existing converter: >>> import curies >>> converter = curies.get_obo_converter() >>> converter.add_prefix("hgnc", "https://bioregistry.io/hgnc:") >>> converter.expand("hgnc:1234") 'https://bioregistry.io/hgnc:1234' >>> converter.expand("GO:0032571") 'http://purl.obolibrary.org/obo/GO_0032571' This can also be used to incrementally build up a converter from scratch: >>> import curies >>> converter = curies.Converter(records=[]) >>> converter.add_prefix("hgnc", "https://bioregistry.io/hgnc:") >>> converter.expand("hgnc:1234") 'https://bioregistry.io/hgnc:1234' """ record = Record( prefix=prefix, uri_prefix=uri_prefix, prefix_synonyms=sorted(prefix_synonyms or []), uri_prefix_synonyms=sorted(uri_prefix_synonyms or []), pattern=pattern, ) self.add_record(record, case_sensitive=case_sensitive, merge=merge) @classmethod def from_extended_prefix_map( cls, records: LocationOr[Iterable[Record | dict[str, Any]]], **kwargs: Any ) -> Converter: """Get a converter from a list of dictionaries by creating records out of them. :param records: One of the following: - An iterable of :class:`curies.Record` objects or dictionaries that will get converted into record objects that together constitute an extended prefix map - A string containing a remote location of a JSON file containg an extended prefix map - A string or :class:`pathlib.Path` object corresponding to a local file path to a JSON file containing an extended prefix map :param kwargs: Keyword arguments to pass to :meth:`curies.Converter.__init__` :returns: A converter An extended prefix map is a list of dictionaries containing four keys: 1. A ``prefix`` string 2. A ``uri_prefix`` string 3. An optional list of strings ``prefix_synonyms`` 4. An optional list of strings ``uri_prefix_synonyms`` Across the whole list of dictionaries, there should be uniqueness within the union of all ``prefix`` and ``prefix_synonyms`` as well as uniqueness within the union of all ``uri_prefix`` and ``uri_prefix_synonyms``. >>> epm = [ ... { ... "prefix": "CHEBI", ... "prefix_synonyms": ["chebi", "ChEBI"], ... "uri_prefix": "http://purl.obolibrary.org/obo/CHEBI_", ... "uri_prefix_synonyms": [ ... "https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:" ... ], ... }, ... { ... "prefix": "GO", ... "uri_prefix": "http://purl.obolibrary.org/obo/GO_", ... }, ... ] >>> converter = Converter.from_extended_prefix_map(epm) Expand using the preferred/canonical prefix: >>> converter.expand("CHEBI:138488") 'http://purl.obolibrary.org/obo/CHEBI_138488' Expand using a prefix synonym: >>> converter.expand("chebi:138488") 'http://purl.obolibrary.org/obo/CHEBI_138488' Compress using the preferred/canonical URI prefix: >>> converter.compress("http://purl.obolibrary.org/obo/CHEBI_138488") 'CHEBI:138488' Compressing using a URI prefix synonym: >>> converter.compress("https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:138488") 'CHEBI:138488' Example from a remote source: >>> url = "https://github.com/biopragmatics/bioregistry/raw/main/exports/contexts/bioregistry.epm.json" >>> converter = Converter.from_extended_prefix_map(url) """ return cls( records=[ record if isinstance(record, Record) else Record(**record) for record in _prepare(records) ], **kwargs, ) @classmethod def from_priority_prefix_map( cls, data: LocationOr[Mapping[str, list[str]]], **kwargs: Any ) -> Converter: """Get a converter from a priority prefix map. :param data: A prefix map where the keys are prefixes (e.g., `chebi`) and the values are lists of URI prefixes (e.g., ``http://purl.obolibrary.org/obo/CHEBI_``) with the first element of the list being the priority URI prefix for expansions. :param kwargs: Keyword arguments to pass to the parent class's init :returns: A converter >>> priority_prefix_map = { ... "CHEBI": [ ... "http://purl.obolibrary.org/obo/CHEBI_", ... "https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:", ... ], ... "GO": ["http://purl.obolibrary.org/obo/GO_"], ... "obo": ["http://purl.obolibrary.org/obo/"], ... } >>> converter = Converter.from_priority_prefix_map(priority_prefix_map) >>> converter.expand("CHEBI:138488") 'http://purl.obolibrary.org/obo/CHEBI_138488' >>> converter.compress("http://purl.obolibrary.org/obo/CHEBI_138488") 'CHEBI:138488' >>> converter.compress("https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:138488") 'CHEBI:138488' """ return cls( [ Record( prefix=prefix, uri_prefix=uri_prefixes[0], uri_prefix_synonyms=uri_prefixes[1:] ) for prefix, uri_prefixes in _prepare(data).items() ], **kwargs, ) @classmethod def from_prefix_map(cls, prefix_map: LocationOr[Mapping[str, str]], **kwargs: Any) -> Converter: """Get a converter from a simple prefix map. :param prefix_map: One of the following: - A mapping whose keys represent CURIE prefixes and values represent URI prefixes - A string containing a remote location of a JSON file containg a prefix map - A string or :class:`pathlib.Path` object corresponding to a local file path to a JSON file containing a prefix map :param kwargs: Keyword arguments to pass to :meth:`curies.Converter.__init__` :returns: A converter >>> converter = Converter.from_prefix_map( ... { ... "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", ... "MONDO": "http://purl.obolibrary.org/obo/MONDO_", ... "GO": "http://purl.obolibrary.org/obo/GO_", ... "OBO": "http://purl.obolibrary.org/obo/", ... } ... ) >>> converter.expand("CHEBI:138488") 'http://purl.obolibrary.org/obo/CHEBI_138488' >>> converter.compress("http://purl.obolibrary.org/obo/CHEBI_138488") 'CHEBI:138488' """ return cls( [ Record(prefix=prefix, uri_prefix=uri_prefix) for prefix, uri_prefix in _prepare(prefix_map).items() ], **kwargs, ) @classmethod def from_reverse_prefix_map( cls, reverse_prefix_map: LocationOr[Mapping[str, str]], **kwargs: Any ) -> Converter: """Get a converter from a reverse prefix map. :param reverse_prefix_map: A mapping whose keys are URI prefixes and whose values are the corresponding prefixes. This data structure allow for multiple different URI formats to point to the same prefix. :param kwargs: Keyword arguments to pass to :meth:`curies.Converter.__init__` :returns: A converter >>> converter = Converter.from_reverse_prefix_map( ... { ... "http://purl.obolibrary.org/obo/CHEBI_": "CHEBI", ... "https://www.ebi.ac.uk/chebi/searchId.do?chebiId=": "CHEBI", ... "http://purl.obolibrary.org/obo/MONDO_": "MONDO", ... } ... ) >>> converter.expand("CHEBI:138488") 'http://purl.obolibrary.org/obo/CHEBI_138488' >>> converter.compress("http://purl.obolibrary.org/obo/CHEBI_138488") 'CHEBI:138488' >>> converter.compress("https://www.ebi.ac.uk/chebi/searchId.do?chebiId=138488") 'CHEBI:138488' Altenatively, get content from the internet like >>> url = "https://github.com/biopragmatics/bioregistry/raw/main/exports/contexts/bioregistry.rpm.json" >>> converter = Converter.from_reverse_prefix_map(url) >>> "chebi" in converter.prefix_map """ dd: defaultdict[str, list[str]] = defaultdict(list) for uri_prefix, prefix in _prepare(reverse_prefix_map).items(): dd[prefix].append(uri_prefix) records = [] for prefix, uri_prefixes in dd.items(): uri_prefix, *uri_prefix_synonyms = sorted(uri_prefixes, key=len) records.append( Record( prefix=prefix, uri_prefix=uri_prefix, uri_prefix_synonyms=uri_prefix_synonyms ) ) return cls(records, **kwargs) @classmethod def from_jsonld(cls, data: LocationOr[dict[str, Any]], **kwargs: Any) -> Converter: """Get a converter from a JSON-LD object, which contains a prefix map in its ``@context`` key. :param data: A JSON-LD object :param kwargs: Keyword arguments to pass to :meth:`curies.Converter.__init__` :returns: A converter Example from a remote context file: >>> base = "https://raw.githubusercontent.com" >>> url = f"{base}/biopragmatics/bioregistry/main/exports/contexts/semweb.context.jsonld" >>> converter = Converter.from_jsonld(url) >>> "rdf" in converter.prefix_map .. seealso:: https://www.w3.org/TR/json-ld11/#the-context defines the ``@context`` aspect of JSON-LD """ prefix_map = {} for key, value in _prepare(data)["@context"].items(): # TODO how to handle key == "@base"? if not key: logger.warning( "The JSON-LD specification says in https://www.w3.org/TR/json-ld/#terms that " "keys are not allowed to be empty strings. The given @context object contained " "an empty string as one of its keys" ) continue if key.startswith("@"): continue if isinstance(value, str): prefix_map[key] = value elif isinstance(value, dict) and value.get("@prefix") is True: prefix_map[key] = value["@id"] return cls.from_prefix_map(prefix_map, **kwargs) @classmethod def from_jsonld_github( cls, owner: str, repo: str, *path: str, branch: str = "main", **kwargs: Any ) -> Converter: """Construct a remote JSON-LD URL on GitHub then parse with :meth:`Converter.from_jsonld`. :param owner: A github repository owner or organization (e.g., ``biopragmatics``) :param repo: The name of the repository (e.g., ``bioregistry``) :param path: The file path in the GitHub repository to a JSON-LD context file. :param branch: The branch from which the file should be downloaded. Defaults to ``main``, for old repositories this might need to be changed to ``master``. :param kwargs: Keyword arguments to pass to :meth:`curies.Converter.__init__` :returns: A converter :raises ValueError: If the given path doesn't end in a .jsonld file name >>> converter = Converter.from_jsonld_github( ... "biopragmatics", ... "bioregistry", ... "exports", ... "contexts", ... "semweb.context.jsonld", ... ) >>> "rdf" in converter.prefix_map True """ if not path or not path[-1].endswith(".jsonld"): raise ValueError("final path argument should end with .jsonld") rest = "/".join(path) url = f"https://raw.githubusercontent.com/{owner}/{repo}/{branch}/{rest}" return cls.from_jsonld(url, **kwargs) @classmethod def from_rdflib( cls, graph_or_manager: rdflib.Graph | rdflib.namespace.NamespaceManager, **kwargs: Any, ) -> Converter: """Get a converter from an RDFLib graph or namespace manager. :param graph_or_manager: A RDFLib graph or manager object :param kwargs: Keyword arguments to pass to :meth:`from_prefix_map` :returns: A converter In the following example, a :class:`rdflib.Graph` is created, a namespace is bound to it, then a converter is made: >>> import rdflib, curies >>> graph = rdflib.Graph() >>> graph.bind("hgnc", "https://bioregistry.io/hgnc:") >>> converter = curies.Converter.from_rdflib(graph) >>> converter.expand("hgnc:1234") 'https://bioregistry.io/hgnc:1234' This also works if you directly start with a :class:`rdflib.namespace.NamespaceManager`: >>> converter = curies.Converter.from_rdflib(graph.namespace_manager) >>> converter.expand("hgnc:1234") 'https://bioregistry.io/hgnc:1234' """ # it's required to stringify namespace since it's a rdflib.URIRef # object, which acts funny if not coerced into a string prefix_map = {prefix: str(namespace) for prefix, namespace in graph_or_manager.namespaces()} return cls.from_prefix_map(prefix_map, **kwargs) def bind_rdflib( self, graph_or_manager: rdflib.Graph | rdflib.namespace.NamespaceManager, synonyms: bool = False, ) -> None: """Add the prefix map from this converter to a RDFlib graph or manager. :param graph_or_manager: A RDFLib graph or manager object :param synonyms: Should CURIE prefix synonyms be bound? Binding a graph: >>> import curies, rdflib >>> converter = curies.get_obo_converter() >>> graph = rdflib.Graph() >>> converter.bind_rdflib(graph) Binding a manager: >>> import curies, rdflib, rdflib.namespace >>> converter = curies.get_obo_converter() >>> manager = rdflib.namespace.NamespaceManager(graph=rdflib.Graph()) >>> converter.bind_rdflib(manager) """ from rdflib import Namespace for record in self.records: namespace = Namespace(record.uri_prefix) graph_or_manager.bind(record.prefix, namespace) if synonyms: for synonym in record.prefix_synonyms: graph_or_manager.bind(synonym, namespace) @classmethod def from_shacl( cls, graph: str | Path | rdflib.Graph, format: str | None = None, **kwargs: Any, ) -> Converter: """Get a converter from SHACL, either in a turtle f. :param graph: A RDFLib graph, a Path, a string representing a file path, or a string URL :param format: The RDF format, if a file path is given :param kwargs: Keyword arguments to pass to :meth:`Converter.__init__` :returns: A converter """ if isinstance(graph, (str, Path)): import rdflib temporary_graph = rdflib.Graph() temporary_graph.parse(location=Path(graph).resolve().as_posix(), format=format) graph = temporary_graph query = """\ SELECT ?curie_prefix ?uri_prefix ?pattern WHERE { ?bnode1 sh:declare ?bnode2 . ?bnode2 sh:prefix ?curie_prefix . ?bnode2 sh:namespace ?uri_prefix . OPTIONAL { ?bnode2 sh:pattern ?pattern . } } """ results = cast(Iterable[tuple[str, str, str]], graph.query(query)) records = [ Record(prefix=str(prefix), uri_prefix=str(uri_prefix), pattern=pattern and str(pattern)) for prefix, uri_prefix, pattern in results ] return cls(records, **kwargs) def get_prefixes(self, *, include_synonyms: bool = False) -> set[str]: """Get the set of prefixes covered by this converter. :param include_synonyms: If true, include secondary prefixes. :returns: A set of primary prefixes covered by the converter. If ``include_synonyms`` is set to ``True``, secondary prefixes (i.e., ones in :data:`Record.prefix_synonyms` are also included """ rv = {record.prefix for record in self.records} if include_synonyms: rv.update( prefix_synonym for record in self.records for prefix_synonym in record.prefix_synonyms ) return rv def get_uri_prefixes(self, *, include_synonyms: bool = False) -> set[str]: """Get the set of URI prefixes covered by this converter. :param include_synonyms: If true, include secondary prefixes. :returns: A set of primary URI prefixes covered by the converter. If ``include_synonyms`` is set to ``True``, secondary URI prefixes (i.e., ones in :data:`Record.uri_prefix_synonyms` are also included """ rv = {record.uri_prefix for record in self.records} if include_synonyms: rv.update( uri_prefix_synonym for record in self.records for uri_prefix_synonym in record.uri_prefix_synonyms ) return rv def format_curie(self, prefix: str, identifier: str) -> str: """Format a prefix and identifier into a CURIE string.""" return f"{prefix}{self.delimiter}{identifier}" def is_uri(self, s: str) -> bool: """Check if the string can be parsed as a URI by this converter. :param s: A string that might be a URI :returns: If the string can be parsed as a URI by this converter. Note that some valid URIs, when passed to this function, will result in False if their URI prefixes are not registered with this converter. >>> import curies >>> converter = curies.get_obo_converter() >>> converter.is_uri("http://purl.obolibrary.org/obo/GO_1234567") True >>> converter.is_uri("GO:1234567") False The following is a valid URI, but the prefix is not registered with the converter based on the OBO Foundry prefix map, so it returns False. >>> converter.is_uri("http://proteopedia.org/wiki/index.php/2gc4") False """ return self.compress(s) is not None # docstr-coverage:excused `overload` @overload def compress_or_standardize( self, uri_or_curie: str, *, strict: Literal[True] = True, passthrough: bool = ... ) -> str: ... # docstr-coverage:excused `overload` @overload def compress_or_standardize( self, uri_or_curie: str, *, strict: Literal[False] = False, passthrough: Literal[True] = True, ) -> str: ... # docstr-coverage:excused `overload` @overload def compress_or_standardize( self, uri_or_curie: str, *, strict: Literal[False] = False, passthrough: Literal[False] = False, ) -> str | None: ... def compress_or_standardize( self, uri_or_curie: str, *, strict: bool = False, passthrough: bool = False ) -> str | None: """Compress a URI or standardize a CURIE. :param uri_or_curie: A string representing a compact URI (CURIE) or a URI. :param strict: If true and the string is neither a URI that can be compressed nor a CURIE that can be standardized, returns an error. Defaults to false. :param passthrough: If true, strict is false, and the string is neither a URI that can be compressed nor a CURIE that can be standardized, return the input. Defaults to false. :returns: If the string is a URI, and it can be compressed, returns the corresponding CURIE. If the string is a CURIE, and it can be standardized, returns the standard CURIE. :raises CompressionError: If strict is true and the URI can't be compressed >>> from curies import Converter, Record >>> converter = Converter.from_extended_prefix_map( ... [ ... Record( ... prefix="CHEBI", ... prefix_synonyms=["chebi"], ... uri_prefix="http://purl.obolibrary.org/obo/CHEBI_", ... uri_prefix_synonyms=["https://identifiers.org/chebi:"], ... ), ... ] ... ) >>> converter.compress_or_standardize("http://purl.obolibrary.org/obo/CHEBI_138488") 'CHEBI:138488' >>> converter.compress_or_standardize("https://identifiers.org/chebi:138488") 'CHEBI:138488' >>> converter.compress_or_standardize("CHEBI:138488") 'CHEBI:138488' >>> converter.compress_or_standardize("chebi:138488") 'CHEBI:138488' >>> converter.compress_or_standardize("missing:0000000") >>> converter.compress_or_standardize("https://example.com/missing:0000000") """ reference = self.parse(uri_or_curie, strict=False) if reference is not None: return self.format_curie(reference.prefix, reference.identifier) if strict: raise CompressionError(uri_or_curie) if passthrough: return uri_or_curie return None # docstr-coverage:excused `overload` @overload def parse( self, str_or_uri_or_curie: str | URIType, *, strict: Literal[True] = True ) -> ReferenceTuple: ... # docstr-coverage:excused `overload` @overload def parse( self, str_or_uri_or_curie: str | URIType, *, strict: Literal[False] = False ) -> ReferenceTuple | None: ... def parse( self, str_or_uri_or_curie: str | URIType, *, strict: bool = False ) -> ReferenceTuple | None: """Parse a string, URI, or CURIE.""" if str_or_uri_or_curie.__class__ is not str or self.is_uri(str_or_uri_or_curie): return self.parse_uri(str_or_uri_or_curie, strict=strict) # type:ignore[no-any-return,call-overload] if self.is_curie(str_or_uri_or_curie): return self.parse_curie(str_or_uri_or_curie, strict=strict) # type:ignore[no-any-return,call-overload] if strict: raise CompressionError(str_or_uri_or_curie) return None def compress_strict(self, uri: URIType) -> str: """Compress a URI to a CURIE, and raise an error of not possible.""" return self.compress(uri, strict=True) # docstr-coverage:excused `overload` @overload def compress( self, uri: URIType, *, strict: Literal[True] = True, passthrough: bool = ... ) -> str: ... # docstr-coverage:excused `overload` @overload def compress( self, uri: URIType, *, strict: Literal[False] = False, passthrough: Literal[True] = True ) -> str: ... # docstr-coverage:excused `overload` @overload def compress( self, uri: URIType, *, strict: Literal[False] = False, passthrough: Literal[False] = False ) -> str | None: ... def compress( self, uri: URIType, *, strict: bool = False, passthrough: bool = False ) -> str | None: """Compress a URI to a CURIE, if possible. :param uri: A string representing a valid uniform resource identifier (URI) :param strict: If true and the URI can't be compressed, returns an error. Defaults to false. :param passthrough: If true, strict is false, and the URI can't be compressed, return the input. Defaults to false. :returns: A compact URI if this converter could find an appropriate URI prefix, otherwise none. :raises CompressionError: If strict is set to true and the URI can't be compressed >>> from curies import Converter >>> converter = Converter.from_prefix_map( ... { ... "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", ... "MONDO": "http://purl.obolibrary.org/obo/MONDO_", ... "GO": "http://purl.obolibrary.org/obo/GO_", ... "OBO": "http://purl.obolibrary.org/obo/", ... } ... ) >>> converter.compress("http://purl.obolibrary.org/obo/GO_0032571") 'GO:0032571' >>> converter.compress("http://purl.obolibrary.org/obo/go.owl") 'OBO:go.owl' >>> converter.compress("http://example.org/missing:0000000") .. note:: If there are partially overlapping *URI prefixes* in this converter (e.g., ``http://purl.obolibrary.org/obo/GO_`` for the prefix ``GO`` and ``http://purl.obolibrary.org/obo/`` for the prefix ``OBO``), the longest URI prefix will always be matched. For example, parsing ``http://purl.obolibrary.org/obo/GO_0032571`` will return ``GO:0032571`` instead of ``OBO:GO_0032571``. """ reference: ReferenceTuple | None = self.parse_uri(uri) if reference: return self.format_curie(reference.prefix, reference.identifier) if strict: raise CompressionError(uri) if passthrough: return str(uri) return None # docstr-coverage:excused `overload` @overload def parse_uri(self, uri: URIType, *, strict: Literal[False] = ...) -> ReferenceTuple | None: ... # docstr-coverage:excused `overload` @overload def parse_uri( self, uri: URIType, *, strict: Literal[True] = True, ) -> ReferenceTuple: ... def parse_uri(self, uri: URIType, *, strict: bool = False) -> ReferenceTuple | None: """Compress a URI to a CURIE pair. :param uri: A string or object representing a valid uniform resource identifier (URI). URIs represented as :class:`rdflib.URIRef`, :class:`pydantic.AnyUrl`, :class:`httpx.URL`, and :class:`httpx2.URL` are accepted in addition to plain strings. :param strict: If true and the URI can't be parsed, returns an error. Defaults to false. :returns: A CURIE pair if the URI could be parsed, otherwise a pair of None's :raises CompressionError: if strict is set to true and the URI can't be parsed >>> from curies import Converter >>> converter = Converter.from_prefix_map( ... { ... "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", ... "MONDO": "http://purl.obolibrary.org/obo/MONDO_", ... "GO": "http://purl.obolibrary.org/obo/GO_", ... } ... ) >>> converter.parse_uri("http://purl.obolibrary.org/obo/CHEBI_138488") ReferenceTuple(prefix='CHEBI', identifier='138488') >>> converter.parse_uri("http://example.org/missing:0000000") """ rv = self.trie.parse_uri(str(uri)) if rv is not None: return rv if strict: raise CompressionError(uri) from None return None def is_curie(self, s: str) -> bool: """Check if the string can be parsed as a CURIE by this converter. :param s: A string that might be a CURIE :returns: If the string can be parsed as a CURIE by this converter. Note that some valid CURIEs, when passed to this function, will result in False if their prefixes are not registered with this converter. >>> import curies >>> converter = curies.get_obo_converter() >>> converter.is_curie("GO:1234567") True >>> converter.is_curie("http://purl.obolibrary.org/obo/GO_1234567") False The following is a valid CURIE, but the prefix is not registered with the converter based on the OBO Foundry prefix map, so it returns False. >>> converter.is_curie("pdb:2gc4") False """ try: return self.expand(s) is not None except ValueError: return False # docstr-coverage:excused `overload` @overload def expand_or_standardize( self, curie_or_uri: str, *, strict: Literal[True] = True, passthrough: bool = ... ) -> str: ... # docstr-coverage:excused `overload` @overload def expand_or_standardize( self, curie_or_uri: str, *, strict: Literal[False] = False, passthrough: Literal[True] = True, ) -> str: ... # docstr-coverage:excused `overload` @overload def expand_or_standardize( self, curie_or_uri: str, *, strict: Literal[False] = False, passthrough: Literal[False] = False, ) -> str | None: ... def expand_or_standardize( self, curie_or_uri: str, *, strict: bool = False, passthrough: bool = False ) -> str | None: """Expand a CURIE or standardize a URI. :param curie_or_uri: A string representing a compact URI (CURIE) or a URI. :param strict: If true and the string is neither a CURIE that can be expanded nor a URI that can be standardized, returns an error. Defaults to false. :param passthrough: If true, strict is false, and the string is neither a CURIE that can be expanded nor a URI that can be standardized, return the input. Defaults to false. :returns: If the string is a CURIE, and it can be expanded, returns the corresponding URI. If the string is a URI, and it can be standardized, returns the standard URI. :raises ExpansionError: If strict is true and the CURIE can't be expanded >>> from curies import Converter, Record >>> converter = Converter.from_extended_prefix_map( ... [ ... Record( ... prefix="CHEBI", ... prefix_synonyms=["chebi"], ... uri_prefix="http://purl.obolibrary.org/obo/CHEBI_", ... uri_prefix_synonyms=["https://identifiers.org/chebi:"], ... ), ... ] ... ) >>> converter.expand_or_standardize("CHEBI:138488") 'http://purl.obolibrary.org/obo/CHEBI_138488' >>> converter.expand_or_standardize("chebi:138488") 'http://purl.obolibrary.org/obo/CHEBI_138488' >>> converter.expand_or_standardize("http://purl.obolibrary.org/obo/CHEBI_138488") 'http://purl.obolibrary.org/obo/CHEBI_138488' >>> converter.expand_or_standardize("https://identifiers.org/chebi:138488") 'http://purl.obolibrary.org/obo/CHEBI_138488' >>> converter.expand_or_standardize("missing:0000000") >>> converter.expand_or_standardize("https://example.com/missing:0000000") """ reference = self.parse(curie_or_uri, strict=False) if reference is not None: return self.expand_reference(reference, strict=strict, passthrough=passthrough) # type:ignore[no-any-return,call-overload] if strict: raise ExpansionError(curie_or_uri) if passthrough: return curie_or_uri return None def expand_strict(self, curie: str) -> str: """Expand a CURIE to a URI, and raise an error of not possible.""" return self.expand(curie, strict=True) # docstr-coverage:excused `overload` @overload def expand( self, curie: str, *, strict: Literal[True] = True, passthrough: bool = ... ) -> str: ... # docstr-coverage:excused `overload` @overload def expand( self, curie: str, *, strict: Literal[False] = False, passthrough: Literal[True] = True ) -> str: ... # docstr-coverage:excused `overload` @overload def expand( self, curie: str, *, strict: Literal[False] = False, passthrough: Literal[False] = False ) -> str | None: ... def expand(self, curie: str, *, strict: bool = False, passthrough: bool = False) -> str | None: """Expand a CURIE to a URI, if possible. :param curie: A string representing a compact URI (CURIE) :param strict: If true and the CURIE can't be expanded, returns an error. Defaults to false. :param passthrough: If true, strict is false, and the CURIE can't be expanded, return the input. Defaults to false. If your strings can either be a CURIE _or_ a URI, consider using :meth:`Converter.expand_or_standardize` instead. :returns: A URI if this converter contains a URI prefix for the prefix in this CURIE :raises ExpansionError: If strict is true and the CURIE can't be expanded >>> from curies import Converter >>> converter = Converter.from_prefix_map( ... { ... "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", ... "MONDO": "http://purl.obolibrary.org/obo/MONDO_", ... "GO": "http://purl.obolibrary.org/obo/GO_", ... } ... ) >>> converter.expand("CHEBI:138488") 'http://purl.obolibrary.org/obo/CHEBI_138488' >>> converter.expand("missing:0000000") """ reference = self.parse_curie(curie, strict=False) if reference is not None: return self.expand_reference(reference, strict=strict, passthrough=passthrough) # type:ignore[no-any-return,call-overload] if strict: raise ExpansionError(curie) if passthrough: return curie return None # docstr-coverage:excused `overload` @overload def expand_all( self, curie: str, *, strict: Literal[False] = False ) -> Collection[str] | None: ... # docstr-coverage:excused `overload` @overload def expand_all(self, curie: str, *, strict: Literal[True] = True) -> Collection[str]: ... def expand_all(self, curie: str, *, strict: bool = False) -> Collection[str] | None: """Expand a CURIE pair to all possible URIs. :param curie: A string representing a compact URI :param strict: If true and the prefix can't be expanded, returns an error. Defaults to false. :returns: A list of URIs that this converter can create for the given CURIE. The first entry is the "standard" URI then others are based on URI prefix synonyms. If the prefix is not registered to this converter, none is returned. :raises PrefixStandardizationError: if the prefix in the CURIE can not be looked up >>> priority_prefix_map = { ... "CHEBI": [ ... "http://purl.obolibrary.org/obo/CHEBI_", ... "https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:", ... ], ... } >>> converter = Converter.from_priority_prefix_map(priority_prefix_map) >>> converter.expand_all("CHEBI:138488") ['http://purl.obolibrary.org/obo/CHEBI_138488', 'https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:138488'] >>> converter.expand_all("NOPE:NOPE") is None True """ reference = self.parse_curie(curie, strict=False) if reference is not None: return self.expand_pair_all(reference.prefix, reference.identifier) if strict: raise PrefixStandardizationError(curie) return None # docstr-coverage:excused `overload` @overload def parse_curie( self, curie: str, *, strict: Literal[False] = False ) -> ReferenceTuple | None: ... # docstr-coverage:excused `overload` @overload def parse_curie(self, curie: str, *, strict: Literal[True] = True) -> ReferenceTuple: ... def parse_curie(self, curie: str, *, strict: bool = False) -> ReferenceTuple | None: """Parse and standardize a CURIE.""" prefix, identifier = _split(curie, sep=self.delimiter) norm_prefix = self.standardize_prefix(prefix, strict=False) if norm_prefix is None: if strict: raise PrefixStandardizationError(prefix) return None norm_identifier = self.standardize_identifier(norm_prefix, identifier) if norm_identifier is None: if strict: raise IdentifierStandardizationError(curie) return None return ReferenceTuple(norm_prefix, norm_identifier) # docstr-coverage:excused `overload` @overload def standardize_identifier( self, standard_prefix: str, identifier: str, *, strict: Literal[True] = ... ) -> str: ... # docstr-coverage:excused `overload` @overload def standardize_identifier( self, standard_prefix: str, identifier: str, *, strict: Literal[False] = ... ) -> str | None: ... def standardize_identifier( self, standard_prefix: str, identifier: str, *, strict: bool = False ) -> str | None: """Standardize an identifier. :param standard_prefix: This is a prefix that has already been standardized using :meth:`standardize_prefix` in this converter :param identifier: An unstandardized identifier :param strict: If true, requires standardization to succeed or throws an error :returns: A standardized identifier. By default, this function is a no-op, meaning that it just returns the identifier as is. You can override the :class:`Converter` class to implement this method to do standardization (e.g., removing redundant prefixes) and to do validation (e.g., checking against a regular expression). """ return identifier # docstr-coverage:excused `overload` @overload def expand_reference( self, reference: ReferenceTuple | Reference, *, strict: Literal[True] = ..., passthrough: bool = ..., ) -> str: ... # docstr-coverage:excused `overload` @overload def expand_reference( self, reference: ReferenceTuple | Reference, *, strict: Literal[False] = ..., passthrough: bool = ..., ) -> str | None: ... def expand_reference( self, reference: ReferenceTuple | Reference, *, strict: bool = False, passthrough: bool = False, ) -> str | None: """Expand a reference.""" uri_prefix = self.prefix_map.get(reference.prefix) if uri_prefix is not None: return uri_prefix + reference.identifier if strict: raise ExpansionError(reference.prefix) if passthrough: return self.format_curie(reference.prefix, reference.identifier) return None # docstr-coverage:excused `overload` @overload def expand_pair( self, prefix: str, identifier: str, *, strict: Literal[True] = True, passthrough: bool = ... ) -> str: ... # docstr-coverage:excused `overload` @overload def expand_pair( self, prefix: str, identifier: str, *, strict: Literal[False] = False, passthrough: bool = ..., ) -> str | None: ... def expand_pair( self, prefix: str, identifier: str, *, strict: bool = False, passthrough: bool = False ) -> str | None: """Expand a CURIE pair to the standard URI. :param prefix: The prefix of the CURIE :param identifier: The local unique identifier of the CURIE :param strict: If true and the prefix can't be expanded, returns an error. Defaults to false. :param passthrough: If true, strict is false, and the prefix can't be expanded, return the input. Defaults to false. :returns: A URI if this converter contains a URI prefix for the prefix in this CURIE >>> from curies import Converter >>> converter = Converter.from_prefix_map( ... { ... "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", ... "MONDO": "http://purl.obolibrary.org/obo/MONDO_", ... "GO": "http://purl.obolibrary.org/obo/GO_", ... } ... ) >>> converter.expand_pair("CHEBI", "138488") 'http://purl.obolibrary.org/obo/CHEBI_138488' >>> converter.expand_pair("missing", "0000000") """ return self.expand_reference( # type:ignore[no-any-return,call-overload] ReferenceTuple(prefix, identifier), strict=strict, passthrough=passthrough ) # docstr-coverage:excused `overload` @overload def expand_pair_all( self, prefix: str, identifier: str, *, strict: Literal[True] = True ) -> Collection[str]: ... # docstr-coverage:excused `overload` @overload def expand_pair_all( self, prefix: str, identifier: str, *, strict: Literal[False] = False ) -> Collection[str] | None: ... def expand_pair_all( self, prefix: str, identifier: str, *, strict: bool = False ) -> Collection[str] | None: """Expand a CURIE pair to all possible URIs. :param prefix: The prefix of the CURIE :param identifier: The local unique identifier of the CURIE :param strict: If true and the prefix can't be expanded, returns an error. Defaults to false. :returns: A list of URIs that this converter can create for the given CURIE. The first entry is the "standard" URI then others are based on URI prefix synonyms. If the prefix is not registered to this converter, none is returned. :raises ExpansionError: if the prefix in the CURIE can not be looked up >>> priority_prefix_map = { ... "CHEBI": [ ... "http://purl.obolibrary.org/obo/CHEBI_", ... "https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:", ... ], ... } >>> converter = Converter.from_priority_prefix_map(priority_prefix_map) >>> converter.expand_pair_all("CHEBI", "138488") ['http://purl.obolibrary.org/obo/CHEBI_138488', 'https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:138488'] >>> converter.expand_pair_all("NOPE", "NOPE") is None True """ record = self._prefix_to_record.get(prefix) if record is not None: rv = [record.uri_prefix + identifier] for uri_prefix_synonyms in record.uri_prefix_synonyms: rv.append(uri_prefix_synonyms + identifier) return rv if strict: raise ExpansionError(prefix) return None # docstr-coverage:excused `overload` @overload def standardize_prefix( self, prefix: str, *, strict: Literal[True] = True, passthrough: bool = False ) -> str: ... # docstr-coverage:excused `overload` @overload def standardize_prefix( self, prefix: str, *, strict: Literal[False] = False, passthrough: Literal[True] = True ) -> str: ... # docstr-coverage:excused `overload` @overload def standardize_prefix( self, prefix: str, *, strict: Literal[False] = False, passthrough: Literal[False] = False ) -> str | None: ... def standardize_prefix( self, prefix: str, *, strict: bool = False, passthrough: bool = False ) -> str | None: """Standardize a prefix. :param prefix: The prefix of the CURIE :param strict: If true and the prefix can't be standardized, returns an error. Defaults to false. :param passthrough: If true, strict is false, and the prefix can't be standardized, return the input. Defaults to false. :returns: The standardized version of this prefix wrt this converter. If the prefix is not registered in this converter, returns none. :raises PrefixStandardizationError: If strict is true and the prefix can't be standardied >>> from curies import Converter, Record >>> converter = Converter.from_extended_prefix_map( ... [ ... Record(prefix="CHEBI", prefix_synonyms=["chebi"], uri_prefix="..."), ... ] ... ) >>> converter.standardize_prefix("chebi") 'CHEBI' >>> converter.standardize_prefix("CHEBI") 'CHEBI' >>> converter.standardize_prefix("NOPE") is None True >>> converter.standardize_prefix("NOPE", passthrough=True) 'NOPE' """ record = self._prefix_to_record.get(prefix) if record: return record.prefix if strict: raise PrefixStandardizationError(prefix) if passthrough: return prefix return None # docstr-coverage:excused `overload` @overload def standardize_curie( self, curie: str, *, strict: Literal[True] = True, passthrough: bool = False ) -> str: ... # docstr-coverage:excused `overload` @overload def standardize_curie( self, curie: str, *, strict: Literal[False] = False, passthrough: Literal[True] = True ) -> str: ... # docstr-coverage:excused `overload` @overload def standardize_curie( self, curie: str, *, strict: Literal[False] = False, passthrough: Literal[False] = False ) -> str | None: ... def standardize_curie( self, curie: str, *, strict: bool = False, passthrough: bool = False ) -> str | None: """Standardize a CURIE. :param curie: A string representing a compact URI (CURIE) :param strict: If true and the CURIE can't be standardized, returns an error. Defaults to false. :param passthrough: If true, strict is false, and the CURIE can't be standardized, return the input. Defaults to false. :returns: A standardized version of the CURIE in case a prefix synonym was used. Note that this function is idempotent, i.e., if you give an already standard CURIE, it will just return it as is. If the CURIE can't be parsed with respect to the records in the converter, None is returned. :raises CURIEStandardizationError: If strict is true and the CURIE can't be standardized >>> from curies import Converter, Record >>> converter = Converter.from_extended_prefix_map( ... [ ... Record( ... prefix="CHEBI", ... prefix_synonyms=["chebi"], ... uri_prefix="http://purl.obolibrary.org/obo/CHEBI_", ... ), ... ] ... ) >>> converter.standardize_curie("chebi:138488") 'CHEBI:138488' >>> converter.standardize_curie("CHEBI:138488") 'CHEBI:138488' >>> converter.standardize_curie("NOPE:NOPE") is None True >>> converter.standardize_curie("NOPE:NOPE", passthrough=True) 'NOPE:NOPE' """ rt = self.parse_curie(curie) if rt is not None: return self.format_curie(*rt) if strict: raise CURIEStandardizationError(curie) if passthrough: return curie return None # docstr-coverage:excused `overload` @overload def standardize_uri( self, uri: str, *, strict: Literal[True] = True, passthrough: bool = False ) -> str: ... # docstr-coverage:excused `overload` @overload def standardize_uri( self, uri: str, *, strict: Literal[False] = False, passthrough: Literal[True] = True ) -> str: ... # docstr-coverage:excused `overload` @overload def standardize_uri( self, uri: str, *, strict: Literal[False] = False, passthrough: Literal[False] = False ) -> str | None: ... def standardize_uri( self, uri: str, *, strict: bool = False, passthrough: bool = False ) -> str | None: """Standardize a URI. :param uri: A string representing a valid uniform resource identifier (URI) :param strict: If true and the URI can't be standardized, returns an error. Defaults to false. :param passthrough: If true, strict is false, and the URI can't be standardized, return the input. Defaults to false. :returns: A standardized version of the URI in case a URI prefix synonym was used. Note that this function is idempotent, i.e., if you give an already standard URI, it will just return it as is. If the URI can't be parsed with respect to the records in the converter, None is returned. :raises URIStandardizationError: If strict is true and the URI can't be standardized >>> from curies import Converter, Record >>> converter = Converter.from_extended_prefix_map( ... [ ... Record( ... prefix="CHEBI", ... uri_prefix="http://purl.obolibrary.org/obo/CHEBI_", ... uri_prefix_synonyms=[ ... "https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:", ... ], ... ), ... ] ... ) >>> converter.standardize_uri( ... "https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:138488" ... ) 'http://purl.obolibrary.org/obo/CHEBI_138488' >>> converter.standardize_uri("http://purl.obolibrary.org/obo/CHEBI_138488") 'http://purl.obolibrary.org/obo/CHEBI_138488' >>> converter.standardize_uri("http://example.org/NOPE") is None True >>> converter.standardize_uri("http://example.org/NOPE", passthrough=True) 'http://example.org/NOPE' """ reference: ReferenceTuple | None = self.parse_uri(uri, strict=False) if reference is not None: # prefix is ensured to be in self.prefix_map because of successful parse return self.prefix_map[reference.prefix] + reference.identifier if strict: raise URIStandardizationError(uri) if passthrough: return uri return None # docstr-coverage:excused `overload` @overload def standardize_reference( self, reference: Reference, *, strict: Literal[True] = ... ) -> Reference: ... # docstr-coverage:excused `overload` @overload def standardize_reference( self, reference: Reference, *, strict: Literal[False] = ... ) -> Reference | None: ... def standardize_reference( self, reference: Reference, *, strict: bool = False ) -> Reference | None: """Standardizes a reference.""" st_prefix = self.standardize_prefix(reference.prefix, strict=False) if st_prefix is None: if strict: raise PrefixStandardizationError(reference.prefix) return None st_identifier = self.standardize_identifier(st_prefix, reference.identifier, strict=False) if st_identifier is None: if strict: raise IdentifierStandardizationError(reference.curie) return None return reference.model_copy( update={"prefix": Prefix(st_prefix), "identifier": st_identifier} ) def pd_compress( self, df: pandas.DataFrame, column: str | int, target_column: str | int | None = None, strict: bool = False, passthrough: bool = False, ambiguous: bool = False, ) -> None: """Convert all URIs in the given column to CURIEs. :param df: A pandas DataFrame :param column: The column in the dataframe containing URIs to convert to CURIEs. :param target_column: The column to put the results in. Defaults to input column. :param strict: If true and the URI can't be compressed, returns an error. Defaults to false. :param passthrough: If true, strict is false, and the URI can't be compressed, return the input. Defaults to false. :param ambiguous: If true, consider the column as containing either CURIEs or URIs. """ if ambiguous: func = partial(self.compress_or_standardize, strict=strict, passthrough=passthrough) else: func = partial(self.compress, strict=strict, passthrough=passthrough) df[column if target_column is None else target_column] = df[column].map(func) def pd_expand( self, df: pandas.DataFrame, column: str | int, target_column: str | int | None = None, strict: bool = False, passthrough: bool = False, ambiguous: bool = False, ) -> None: """Convert all CURIEs in the given column to URIs. :param df: A pandas DataFrame :param column: The column in the dataframe containing CURIEs to convert to URIs. :param target_column: The column to put the results in. Defaults to input column. :param strict: If true and the CURIE can't be expanded, returns an error. Defaults to false. :param passthrough: If true, strict is false, and the CURIE can't be expanded, return the input. Defaults to false. :param ambiguous: If true, consider the column as containing either CURIEs or URIs. """ if ambiguous: func = partial(self.expand_or_standardize, strict=strict, passthrough=passthrough) else: func = partial(self.expand, strict=strict, passthrough=passthrough) df[column if target_column is None else target_column] = df[column].map(func) def pd_standardize_prefix( self, df: pandas.DataFrame, *, column: str | int, target_column: str | int | None = None, strict: bool = False, passthrough: bool = False, ) -> None: """Standardize all prefixes in the given column. :param df: A pandas DataFrame :param column: The column in the dataframe containing prefixes to standardize. :param target_column: The column to put the results in. Defaults to input column. :param strict: If true and any prefix can't be standardized, returns an error. Defaults to false. :param passthrough: If true, strict is false, and any prefix can't be standardized, return the input. Defaults to false. """ func = partial(self.standardize_prefix, strict=strict, passthrough=passthrough) df[column if target_column is None else target_column] = df[column].map(func) def pd_standardize_curie( self, df: pandas.DataFrame, *, column: str | int, target_column: str | int | None = None, strict: bool = False, passthrough: bool = False, ) -> None: r"""Standardize all CURIEs in the given column. :param df: A pandas DataFrame :param column: The column in the dataframe containing CURIEs to standardize. :param target_column: The column to put the results in. Defaults to input column. :param strict: If true and any CURIE can't be standardized, returns an error. Defaults to false. :param passthrough: If true, strict is false, and any CURIE can't be standardized, return the input. Defaults to false. The Disease Ontology curates mappings to other semantic spaces and distributes them in the tabular SSSOM format. However, they use a wide variety of non-standard prefixes for referring to external vocabularies like SNOMED-CT. The Bioregistry contains these synonyms to support reconciliation. The following example shows how the SSSOM mappings dataframe can be loaded and this function applied to the mapping ``object_id`` column (in place). >>> import curies >>> import pandas as pd >>> commit = "faca4fc335f9a61902b9c47a1facd52a0d3d2f8b" >>> url = f"https://raw.githubusercontent.com/mapping-commons/disease-mappings/{commit}/mappings/doid.sssom.tsv" >>> df = pd.read_csv(url, sep="\t", comment="#") >>> converter = curies.get_bioregistry_converter() >>> converter.pd_standardize_curie(df, column="object_id") """ func = partial(self.standardize_curie, strict=strict, passthrough=passthrough) df[column if target_column is None else target_column] = df[column].map(func) def pd_standardize_uri( self, df: pandas.DataFrame, *, column: str | int, target_column: str | int | None = None, strict: bool = False, passthrough: bool = False, ) -> None: """Standardize all URIs in the given column. :param df: A pandas DataFrame :param column: The column in the dataframe containing URIs to standardize. :param target_column: The column to put the results in. Defaults to input column. :param strict: If true and any URI can't be standardized, returns an error. Defaults to false. :param passthrough: If true, strict is false, and any URI can't be standardized, return the input. Defaults to false. """ func = partial(self.standardize_uri, strict=strict, passthrough=passthrough) df[column if target_column is None else target_column] = df[column].map(func) def file_compress( self, path: str | Path, column: int, *, sep: str | None = None, header: bool = True, strict: bool = False, passthrough: bool = False, ambiguous: bool = False, ) -> None: """Convert all URIs in the given column of a CSV file to CURIEs. :param path: A pandas DataFrame :param column: The column in the dataframe containing URIs to convert to CURIEs. :param sep: The delimiter of the CSV file, defaults to tab :param header: Does the file have a header row? :param strict: If true and the URI can't be compressed, returns an error. Defaults to false. :param passthrough: If true, strict is false, and the URI can't be compressed, return the input. Defaults to false. :param ambiguous: If true, consider the column as containing either CURIEs or URIs. """ if ambiguous: func = partial(self.compress_or_standardize, strict=strict, passthrough=passthrough) else: func = partial(self.compress, strict=strict, passthrough=passthrough) self._file_helper(func, path=path, column=column, sep=sep, header=header) def file_expand( self, path: str | Path, column: int, *, sep: str | None = None, header: bool = True, strict: bool = False, passthrough: bool = False, ambiguous: bool = False, ) -> None: """Convert all CURIEs in the given column of a CSV file to URIs. :param path: A pandas DataFrame :param column: The column in the dataframe containing CURIEs to convert to URIs. :param sep: The delimiter of the CSV file, defaults to tab :param header: Does the file have a header row? :param strict: If true and the CURIE can't be expanded, returns an error. Defaults to false. :param passthrough: If true, strict is false, and the CURIE can't be expanded, return the input. Defaults to false. :param ambiguous: If true, consider the column as containing either CURIEs or URIs. """ if ambiguous: func = partial(self.expand_or_standardize, strict=strict, passthrough=passthrough) else: func = partial(self.expand, strict=strict, passthrough=passthrough) self._file_helper(func, path=path, column=column, sep=sep, header=header) @staticmethod def _file_helper( func: Callable[[str], str | None], path: str | Path, column: int, sep: str | None = None, header: bool = True, ) -> None: path = Path(path).expanduser().resolve() rows = [] delimiter = sep or "\t" with path.open() as file_in: reader = csv.reader(file_in, delimiter=delimiter) _header = next(reader) if header else None for row in reader: row[column] = func(row[column]) or "" rows.append(row) with path.open("w") as file_out: writer = csv.writer(file_out, delimiter=delimiter) if _header: writer.writerow(_header) writer.writerows(rows) # docstr-coverage:excused `overload` @overload def get_record(self, prefix: str, *, strict: Literal[True] = True) -> Record: ... # docstr-coverage:excused `overload` @overload def get_record(self, prefix: str, *, strict: Literal[False] = False) -> Record | None: ... def get_record(self, prefix: str, *, strict: bool = False) -> Record | None: """Get the record for the prefix.""" # TODO use self._prefix_to_record for record in self.records: if record.prefix == prefix or prefix in record.prefix_synonyms: return record if strict: raise KeyError(f"could not find prefix: {prefix}") return None def get_subconverter(self, prefixes: Iterable[str]) -> Converter: r"""Get a converter with a subset of prefixes. :param prefixes: A list of prefixes to keep from this converter. These can correspond either to preferred CURIE prefixes or CURIE prefix synonyms. :returns: A new, slimmed down converter This functionality is useful for downstream applications like the following: 1. You load a comprehensive extended prefix map, e.g., from the Bioregistry using :func:`curies.get_bioregistry_converter()`. 2. You load some data that conforms to this prefix map by convention. This is often the case for semantic mappings stored in the `SSSOM format `_. 3. You extract the list of prefixes *actually* used within your data 4. You subset the detailed extended prefix map to only include prefixes relevant for your data 5. You make some kind of output of the subsetted extended prefix map to go with your data. Effectively, this is a way of reconciling data. This is especially effective when using the Bioregistry or other comprehensive extended prefix maps. Here's a concrete example of doing this (which also includes a bit of data science) to do this on the SSSOM mappings from the `Disease Ontology `_ project. >>> import curies >>> import pandas as pd >>> import itertools as itt >>> commit = "faca4fc335f9a61902b9c47a1facd52a0d3d2f8b" >>> url = f"https://raw.githubusercontent.com/mapping-commons/disease-mappings/{commit}/mappings/doid.sssom.tsv" >>> df = pd.read_csv(url, sep="\t", comment="#") >>> prefixes = { ... curies.Reference.from_curie(curie).prefix ... for column in ["subject_id", "predicate_id", "object_id"] ... for curie in df[column] ... } >>> converter = curies.get_bioregistry_converter() >>> slim_converter = converter.get_subconverter(prefixes) """ prefixes = set(prefixes) records = [ record for record in self.records if any(prefix in prefixes for prefix in record._all_prefixes) ] return Converter(records) def hash_triple(self, triple: Triple, *, negate: bool = False) -> str: """Hash a triple using :func:`curies.triples.hash_triple`, implementing https://ts4nfdi.github.io/mapping-sameness-identifier. :param triple: A subject-predicate-object triple :param negate: If true, considers the triple as "negative" and postpends a ``~`` to the hash :returns: A hexadecimal digest of the SHA-256 hash of the space-joined expanded URI triple >>> import curies >>> from curies import Triple, Converter >>> converter = curies.load_prefix_map( ... { ... "mesh": "http://id.nlm.nih.gov/mesh/", ... "skos": "http://www.w3.org/2004/02/skos/core#", ... "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", ... } ... ) >>> triple = Triple( ... subject="mesh:C000089", ... predicate="skos:exactMatch", ... object="CHEBI:28646", ... ) >>> converter.hash_triple(triple) '36a1f9244ea7641a90987c82f33c25c0c13712ee8f48207b2a0825f8a4e4e26a' >>> converter.hash_triple(triple, negate=True) '36a1f9244ea7641a90987c82f33c25c0c13712ee8f48207b2a0825f8a4e4e26a~' """ from .triples import hash_triple return hash_triple(self, triple, negate=negate) def chain(converters: Sequence[Converter], *, case_sensitive: bool = True) -> Converter: """Chain several converters. :param converters: A list or tuple of converters :param case_sensitive: If false, will not allow case-sensitive duplicates :returns: A converter that looks up one at a time in the other converters. :raises ValueError: If there are no converters Chain is the perfect tool if you want to override parts of an existing extended prefix map. For example, if you want to use most of the Bioregistry, but you would like to specify a custom URI prefix (e.g., using Identifiers.org), you can do the following: >>> import curies >>> bioregistry_converter = curies.get_bioregistry_converter() >>> overrides = curies.load_prefix_map({"pubmed": "https://identifiers.org/pubmed:"}) >>> converter = curies.chain([overrides, bioregistry_converter]) >>> converter.bimap["pubmed"] 'https://identifiers.org/pubmed:' Similarly, this also works if you want to override a prefix. Keep in mind for this to work with a simple prefix map, you need to make sure the URI prefix matches in each converter, otherwise you will get duplicates: >>> overrides = curies.load_prefix_map({"PMID": "https://www.ncbi.nlm.nih.gov/pubmed/"}) >>> converter = chain([overrides, bioregistry_converter]) >>> converter.bimap["PMID"] 'https://www.ncbi.nlm.nih.gov/pubmed/' A safer way is to specify your override using an extended prefix map, which can tie together prefix synonyms and URI prefix synonyms: >>> import curies >>> from curies import Converter, chain, get_bioregistry_converter >>> overrides = curies.load_extended_prefix_map( ... [ ... { ... "prefix": "PMID", ... "prefix_synonyms": ["pubmed", "PubMed"], ... "uri_prefix": "https://www.ncbi.nlm.nih.gov/pubmed/", ... "uri_prefix_synonyms": [ ... "https://identifiers.org/pubmed:", ... "http://bio2rdf.org/pubmed:", ... ], ... }, ... ] ... ) >>> converter = curies.chain([overrides, bioregistry_converter]) >>> converter.bimap["PMID"] 'https://www.ncbi.nlm.nih.gov/pubmed/' Chain prioritizes based on the order given. Therefore, if two prefix maps having the same prefix but different URI prefixes are given, the first is retained >>> c1 = curies.load_prefix_map({"GO": "http://purl.obolibrary.org/obo/GO_"}) >>> c2 = curies.load_prefix_map({"GO": "https://identifiers.org/go:"}) >>> c3 = curies.chain([c1, c2]) >>> c3.prefix_map["GO"] 'http://purl.obolibrary.org/obo/GO_' """ converters = list(converters) if not converters: raise ValueError if len(converters) == 1: return converters[0] rv = Converter() for converter in converters: for record in converter.records: rv.add_record(record, case_sensitive=case_sensitive, merge=True) return rv def load_prefix_map(prefix_map: LocationOr[Mapping[str, str]], **kwargs: Any) -> Converter: """Get a converter from a simple prefix map. :param prefix_map: One of the following: - A mapping whose keys represent CURIE prefixes and values represent URI prefixes - A string containing a remote location of a JSON file containg a prefix map - A string or :class:`pathlib.Path` object corresponding to a local file path to a JSON file containing a prefix map :param kwargs: Keyword arguments to pass to :meth:`curies.Converter.__init__` :returns: A converter >>> import curies >>> converter = curies.load_prefix_map( ... { ... "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", ... } ... ) >>> converter.expand("CHEBI:138488") 'http://purl.obolibrary.org/obo/CHEBI_138488' >>> converter.compress("http://purl.obolibrary.org/obo/CHEBI_138488") 'CHEBI:138488' """ return Converter.from_prefix_map(prefix_map, **kwargs) def load_extended_prefix_map( records: LocationOr[Iterable[Record | dict[str, Any]]], **kwargs: Any ) -> Converter: """Get a converter from a list of dictionaries by creating records out of them. :param records: One of the following: - An iterable of :class:`curies.Record` objects or dictionaries that will get converted into record objects that together constitute an extended prefix map - A string containing a remote location of a JSON file containg an extended prefix map - A string or :class:`pathlib.Path` object corresponding to a local file path to a JSON file containing an extended prefix map :param kwargs: Keyword arguments to pass to :meth:`curies.Converter.__init__` :returns: A converter An extended prefix map is a list of dictionaries containing four keys: 1. A ``prefix`` string 2. A ``uri_prefix`` string 3. An optional list of strings ``prefix_synonyms`` 4. An optional list of strings ``uri_prefix_synonyms`` Across the whole list of dictionaries, there should be uniqueness within the union of all ``prefix`` and ``prefix_synonyms`` as well as uniqueness within the union of all ``uri_prefix`` and ``uri_prefix_synonyms``. >>> import curies >>> epm = [ ... { ... "prefix": "CHEBI", ... "prefix_synonyms": ["chebi", "ChEBI"], ... "uri_prefix": "http://purl.obolibrary.org/obo/CHEBI_", ... "uri_prefix_synonyms": ["https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:"], ... }, ... { ... "prefix": "GO", ... "uri_prefix": "http://purl.obolibrary.org/obo/GO_", ... }, ... ] >>> converter = curies.load_extended_prefix_map(epm) Expand using the preferred/canonical prefix: >>> converter.expand("CHEBI:138488") 'http://purl.obolibrary.org/obo/CHEBI_138488' Expand using a prefix synonym: >>> converter.expand("chebi:138488") 'http://purl.obolibrary.org/obo/CHEBI_138488' Compress using the preferred/canonical URI prefix: >>> converter.compress("http://purl.obolibrary.org/obo/CHEBI_138488") 'CHEBI:138488' Compressing using a URI prefix synonym: >>> converter.compress("https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:138488") 'CHEBI:138488' Example from a remote source: >>> url = "https://github.com/biopragmatics/bioregistry/raw/main/exports/contexts/bioregistry.epm.json" >>> converter = curies.load_extended_prefix_map(url) """ return Converter.from_extended_prefix_map(records, **kwargs) def load_jsonld_context(data: LocationOr[dict[str, Any]], **kwargs: Any) -> Converter: """Get a converter from a JSON-LD object, which contains a prefix map in its ``@context`` key. :param data: A JSON-LD object :param kwargs: Keyword arguments to pass to :meth:`curies.Converter.__init__` :returns: A converter Example from a remote context file: >>> base = "https://raw.githubusercontent.com" >>> url = f"{base}/biopragmatics/bioregistry/main/exports/contexts/semweb.context.jsonld" >>> converter = Converter.from_jsonld(url) >>> "rdf" in converter.prefix_map """ return Converter.from_jsonld(data, **kwargs) def load_shacl(data: LocationOr[rdflib.Graph], **kwargs: Any) -> Converter: """Get a converter from a JSON-LD object, which contains a prefix map in its ``@context`` key. :param data: A path to an RDF file or a RDFlib graph :param kwargs: Keyword arguments to pass to :meth:`curies.Converter.__init__` :returns: A converter """ return Converter.from_shacl(data, **kwargs) def write_extended_prefix_map(converter: Converter, path: str | Path) -> None: """Write an extended prefix map as JSON to a file.""" path = _ensure_path(path) path.write_text( json.dumps( [_record_to_dict(record) for record in converter.records], indent=4, sort_keys=True, ensure_ascii=False, ) ) def _record_to_dict(record: Record) -> Mapping[str, str | list[str]]: """Convert a record to a dict.""" rv: dict[str, str | list[str]] = { "prefix": record.prefix, "uri_prefix": record.uri_prefix, } if record.prefix_synonyms: rv["prefix_synonyms"] = sorted(record.prefix_synonyms) if record.uri_prefix_synonyms: rv["uri_prefix_synonyms"] = sorted(record.uri_prefix_synonyms) if record.pattern: rv["pattern"] = record.pattern return rv def _ensure_path(path: str | Path) -> Path: if isinstance(path, str): path = Path(path).resolve() return path def _get_jsonld_context( converter: Converter, *, expand: bool = False, include_synonyms: bool = False ) -> dict[str, Any]: """Get a JSON-LD context based on the converter.""" context = {} for record in converter.records: term = _get_expanded_term(record, expand=expand) context[record.prefix] = term if include_synonyms: for prefix_synonym in record.prefix_synonyms: context[prefix_synonym] = term return {"@context": context} def write_jsonld_context( converter: Converter, path: str | Path, *, include_synonyms: bool = False, expand: bool = False, ) -> None: """Write the converter's bijective map as a JSON-LD context to a file. :param converter: The converter to export :param path: The path to a file to write to :param include_synonyms: If true, includes CURIE prefix synonyms. URI prefix synonyms are not output. :param expand: If False, output a dictionary-like ``@context`` element. If True, use ``@prefix`` and ``@id`` as keys for the CURIE prefix and URI prefix, respectively, to maximize compatibility. The following example shows writing a JSON-LD context: .. code-block:: python import curies converter = curies.load_prefix_map( { "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", } ) curies.write_jsonld_context(converter, "example_context.json") .. code-block:: json { "@context": { "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_" } } Because some implementations of JSON-LD do not like URI prefixes that end with an underscore ``_``, we can use the ``expand`` keyword to turn on more verbose JSON-LD context output that contains explicit ``@prefix`` and ``@id`` annotations .. code-block:: python import curies converter = curies.load_prefix_map( { "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", } ) curies.write_jsonld_context(converter, "example_context.json", expand=True) .. code-block:: json { "@context": { "CHEBI": { "@id": "http://purl.obolibrary.org/obo/CHEBI_", "@prefix": true } } } """ path = _ensure_path(path) obj = _get_jsonld_context(converter, include_synonyms=include_synonyms, expand=expand) with path.open("w") as file: json.dump(obj, file, indent=4, sort_keys=True) def _get_expanded_term(record: Record, *, expand: bool) -> str | dict[str, Any]: if not expand: return record.uri_prefix # Use expanded term definition described in https://www.w3.org/TR/json-ld11/#expanded-term-definition rv = {"@prefix": True, "@id": record.uri_prefix} # TODO add an @context inside here to somehow capture the pattern, if available # if record.pattern: # rv["@context"] = { # "sh": "http://www.w3.org/ns/shacl#", # "sh:pattern": record.pattern, # } return rv def write_shacl( converter: Converter, path: str | Path, *, include_synonyms: bool = False, ) -> None: """Write the converter's bijective map as SHACL in turtle RDF to a file. :param converter: The converter to export :param path: The path to a file to write to :param include_synonyms: If true, includes CURIE prefix synonyms. URI prefix synonyms are not output. .. seealso:: https://www.w3.org/TR/shacl/#sparql-prefixes .. code-block:: python import curies converter = curies.load_prefix_map( { "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", } ) curies.write_shacl(converter, "example_shacl.ttl") .. code-block:: @prefix sh: . @prefix xsd: . [ sh:declare [ sh:prefix "CHEBI" ; sh:namespace "http://purl.obolibrary.org/obo/CHEBI_"^^xsd:anyURI ] ] . """ text = dedent( """\ @prefix sh: . @prefix xsd: . [ sh:declare {entries} ] . """ ) path = _ensure_path(path) lines = [] for record in converter.records: lines.append(_get_shacl_line(record.prefix, record.uri_prefix, pattern=record.pattern)) if include_synonyms: for prefix_synonym in record.prefix_synonyms: lines.append( _get_shacl_line(prefix_synonym, record.uri_prefix, pattern=record.pattern) ) path.write_text(text.format(entries=",\n".join(lines))) def write_tsv( converter: Converter, path: str | Path, *, header: tuple[str, str] = ("prefix", "base") ) -> None: """Write a simple prefix map CSV file. :param converter: The converter to export :param path: The path to a file to write to :param header: A 2-tuple of strings representing the header used in the file, where the first element is the label for CURIE prefixes and the second element is the label for URI prefixes .. code-block:: python import curies converter = curies.load_prefix_map( { "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", } ) curies.write_tsv(converter, "example_context.tsv") .. code-block:: prefix base CHEBI http://purl.obolibrary.org/obo/CHEBI_ """ import csv path = _ensure_path(path) with path.open("w") as csvfile: writer = csv.writer(csvfile, delimiter="\t") writer.writerow(header) for record in converter.records: writer.writerow((record.prefix, record.uri_prefix)) def _get_shacl_line(prefix: str, uri_prefix: str, pattern: str | None = None) -> str: line = f' [ sh:prefix "{prefix}" ; sh:namespace "{uri_prefix}"^^xsd:anyURI ' if pattern: pattern = pattern.replace("\\", "\\\\") line += f'; sh:pattern "{pattern}"' return line + " ]" def upgrade_prefix_map(prefix_map: Mapping[str, str]) -> list[Record]: """Convert a (potentially problematic) prefix map (i.e., not bijective) into a list of records. A prefix map is bijective if it has no duplicate CURIE prefixes (i.e., keys in a dictionary) and no duplicate URI prefixes (i.e., values in a dictionary). Because of the way that dictionaries work in Python, we are always guaranteed that there are no duplicate keys. However, it is both possible and frequent to have duplicate values. This happens because many semantic spaces have multiple synonymous CURIE prefixes. For example, the `OBO in OWL `_ vocabulary has two common, interchangable prefixes: ``oio`` and ``oboInOwl`` (and the case variant ``oboinowl``). Therefore, a prefix map might contain the following parts that make it non-bijective: .. code-block:: json { "oio": "http://www.geneontology.org/formats/oboInOwl#", "oboInOwl": "http://www.geneontology.org/formats/oboInOwl#" } This is bad because this prefix map can't be used to determinstically compress a URI. For example, should ``http://www.geneontology.org/formats/oboInOwl#hasDbXref`` be compressed to ``oio:hasDbXref`` or ``oboInOwl:hasDbXref``? Neither is necessarily incorrect, but the issue here is that there is not an explicit choice by the data modeler, meaning that data compressed into CURIEs with this non-bijective map might not be readily integrable with other datasets. The best solution to this situation is not more code, but rather for the data modeler to address the issue upstream in the following steps: 1. Choose the which of prefix synonyms is going to be the primary prefix. If you're not sure, the `Bioregistry `_ is a comprehensive registry of prefixes and their syonyms applicable in the semantic web and the natural sciences. It gives a good suggestion of what the best prefix is. In the OBO in OWL case, it suggests ``oboInOwl``. 2. Update all related data artifacts to only use that preferred prefix 3. Either 1) remove the other synonyms (in this example, ``oio``) from the prefix map *or* 2) transition to using :ref:`epms`, a more modern data structure for supporting URI and CURIE interconversion. The first part of step 3 in this solution highlights one of the key shortcomings of prefix maps themselves - they can't keep track of synonyms, which are often useful in data integration, especially when a single prefix map is defined on the level of a project or community. The extended prefix map is a simple data structure proposed to address this. - - - This function is for people who are not in the position to make the sustainable fix, and want to automate the assignment of which is the preferred prefix. It uses a deterministic algorithm to choose from two or more CURIE prefixes that have the same URI prefix and generate an extended prefix map in which they have bene collapsed into a single record. More specitically, the algorithm is based on a case-sensitive lexical sort of the prefixes. The first in the sort order becomes the primary prefix and the others become synonyms in the resulting record. :param prefix_map: A mapping whose keys represent CURIE prefixes and values represent URI prefixes :returns: A list of :class:`curies.Record` objects that together constitute an extended prefix map >>> from curies import Converter, upgrade_prefix_map >>> pm = {"a": "https://example.com/a/", "b": "https://example.com/a/"} >>> records = upgrade_prefix_map(pm) >>> converter = Converter(records) >>> converter.expand("a:1") 'https://example.com/a/1' >>> converter.expand("b:1") 'https://example.com/a/1' >>> converter.compress("https://example.com/a/1") 'a:1' .. note:: Thanks to `Joe Flack `_ for proposing this algorithm `in this discussion `_. """ uri_prefix_to_curie_synonyms = defaultdict(list) for curie_prefix, uri_prefix in prefix_map.items(): uri_prefix_to_curie_synonyms[uri_prefix].append(curie_prefix) priority_prefix_map = { uri_prefix: sorted(curie_prefixes) for uri_prefix, curie_prefixes in uri_prefix_to_curie_synonyms.items() } return [ Record(prefix=prefix, prefix_synonyms=prefix_synonyms, uri_prefix=uri_prefix) for uri_prefix, (prefix, *prefix_synonyms) in sorted(priority_prefix_map.items()) ] def _converter_from_validation_info(info: core_schema.ValidationInfo) -> Converter | None: context = info.context or {} if isinstance(context, Converter): return context elif isinstance(context, dict): return context.get("converter") else: raise TypeError class Trie(UserDict[str, Record]): """A partial implementation of a string trie.""" root: TrieNode def __init__(self, initial_dict: dict[str, Record] | None = None) -> None: """Create a new string trie.""" super().__init__() self.root = TrieNode() if initial_dict: for key, value in initial_dict.items(): self[key] = value def __setitem__(self, key: str, item: Record) -> None: self.root._ensure_node(key).value = item def parse_uri(self, uri: str) -> ReferenceTuple | None: """Parse a URI into a prefix/identifier pair based prefixes in the trie.""" node: TrieNode = self.root record: Record | None = self.root.value max_non_null_index = -1 for i, character in enumerate(uri): new_node = node.children.get(character) if new_node is None: break if new_node.value is not None: record = new_node.value max_non_null_index = i node = new_node if record is None: return None identifier = uri[max_non_null_index + 1 :] return ReferenceTuple(record.prefix, identifier) def __contains__(self, key: Any) -> bool: node = self.root._find_node(key) return node is not None and node.value is not None class TrieNode: """Trie node class.""" __slots__ = ("children", "value") value: Record | None children: dict[str, TrieNode] def __init__(self, value: Record | None = None) -> None: """Initialize the node.""" self.value = value # this needs to be mutable, which is why this isn't a named tuple self.children = {} def _ensure_node(self, key: str) -> TrieNode: node = self for character in key: next_node: TrieNode | None = node.children.get(character) if next_node is None: node = node.children.setdefault(character, TrieNode()) else: node = next_node return node def _find_node(self, key: Sequence[str]) -> TrieNode | None: node = self for character in key: next_node = node.children.get(character) if next_node is None: return None node = next_node return node biopragmatics-curies-aa8bd37/src/curies/cli.py000066400000000000000000000126461525104130300215260ustar00rootroot00000000000000"""This package comes with a built-in CLI for running a resolver web application. .. code-block:: $ python -m curies resolver --host 0.0.0.0 --port 8764 bioregistry The positional argument can be one of the following: 1. A pre-defined prefix map to get from the web (bioregistry, go, obo, monarch, prefixcommons) 2. A local file path or URL to a prefix map, extended prefix map, or one of several formats. Requires specifying a `--format`. The framework can be swapped to use Flask (default) or FastAPI with `--framework`. The server can be swapped to use Werkzeug (default) or Uvicorn with `--server`. These functionalities are also available programmatically (see :func:`get_flask_app` and :func:`get_fastapi_app`). Similarly, there's a built-in CLI for running a mapper web application. .. code-block:: $ python -m curies mapper --host 0.0.0.0 --port 8764 bioregistry The same flags and arguments are applicable. """ from __future__ import annotations import sys from collections.abc import Callable, Mapping from typing import TYPE_CHECKING, TypeAlias import click from curies import Converter, sources if TYPE_CHECKING: import fastapi import flask __all__ = [ "main", ] AppHint: TypeAlias = "flask.Flask | fastapi.FastAPI" LOADERS: dict[str, Callable[[str], Converter]] = { "jsonld": Converter.from_jsonld, "prefix_map": Converter.from_prefix_map, "extended_prefix_map": Converter.from_extended_prefix_map, "reverse_prefix_map": Converter.from_reverse_prefix_map, "priority_prefix_map": Converter.from_priority_prefix_map, } CONVERTERS: Mapping[str, Callable[[], Converter]] = { "bioregistry": sources.get_bioregistry_converter, "go": sources.get_go_converter, "monarch": sources.get_monarch_converter, "obo": sources.get_obo_converter, "prefixcommons": sources.get_prefixcommons_converter, } def _get_converter(location: str, format: str | None) -> Converter: if location in CONVERTERS: return CONVERTERS[location]() if format is None: click.secho("--format is required with remote data", fg="red") return sys.exit(1) return LOADERS[format](location) def _get_resolver_app(converter: Converter, framework: str) -> AppHint: from curies import resolver_service if framework == "flask": return resolver_service.get_flask_app(converter) elif framework == "fastapi": return resolver_service.get_fastapi_app(converter) else: raise ValueError(f"Unhandled framework: {framework}") def _get_mapper_app(converter: Converter, framework: str) -> AppHint: from curies import mapping_service if framework == "flask": return mapping_service.get_flask_mapping_app(converter) elif framework == "fastapi": return mapping_service.get_fastapi_mapping_app(converter) else: raise ValueError(f"Unhandled framework: {framework}") def _run_app(app: AppHint, server: str, host: str, port: int) -> None: if server == "uvicorn": import uvicorn uvicorn.run(app, host=host, port=port) elif server == "werkzeug": import flask if not isinstance(app, flask.Flask): raise NotImplementedError app.run(host=host, port=port) elif server == "gunicorn": raise NotImplementedError else: raise ValueError(f"Unhandled server: {server}") LOCATION_ARGUMENT = click.argument("location") FRAMEWORK_OPTION = click.option( "--framework", default="flask", type=click.Choice(["flask", "fastapi"]), show_default=True, help="The framework used to implement the app. Note, each requires different packages to be installed.", ) SERVER_OPTION = click.option( "--server", default="werkzeug", type=click.Choice(["werkzeug", "uvicorn", "gunicorn"]), show_default=True, help="The web server used to run the app. Note, each requires different packages to be installed.", ) FORMAT_OPTION = click.option( "--format", type=click.Choice(list(LOADERS)), help="The data structure of the resolver data. Required if not giving a pre-defined converter name.", ) HOST_OPTION = click.option( "--host", default="0.0.0.0", # noqa:S104 show_default=True, help="The host where the resolver runs", ) PORT_OPTION = click.option( "--port", type=int, default=8764, show_default=True, help="The port where the resolver runs" ) @click.group() def main() -> None: """Run the `curies` CLI.""" @main.command( help="""\ Location can either be the name of a built-in converter, a file path, or a URL. """ ) @LOCATION_ARGUMENT @FRAMEWORK_OPTION @SERVER_OPTION @FORMAT_OPTION @HOST_OPTION @PORT_OPTION def resolver(location: str, host: str, port: int, framework: str, format: str, server: str) -> None: """Serve a resolver app.""" converter = _get_converter(location, format) app = _get_resolver_app(converter, framework=framework) _run_app(app, server=server, host=host, port=port) @main.command( help="""\ Location can either be the name of a built-in converter, a file path, or a URL. """ ) @LOCATION_ARGUMENT @FRAMEWORK_OPTION @SERVER_OPTION @FORMAT_OPTION @HOST_OPTION @PORT_OPTION def mapper(location: str, host: str, port: int, framework: str, format: str, server: str) -> None: """Serve a mapper app.""" converter = _get_converter(location, format) app = _get_mapper_app(converter, framework=framework) _run_app(app, server=server, host=host, port=port) if __name__ == "__main__": main() biopragmatics-curies-aa8bd37/src/curies/database.py000066400000000000000000000324501525104130300225160ustar00rootroot00000000000000"""Database adapters for :mod:`curies`. ####################### Using :mod:`sqlmodel` ####################### SQLModel is a joint abstraction over :mod:`pydantic` and :mod:`sqlalchemy`. If you want to use :class:`curies.Reference` within a SQLModel class, you can do so by setting the SQLAlchemy column type through the ``sa_column`` keyword argument to the results returned by :func:`get_reference_sa_column`, For example, this can be used to model a semantic triple, which has a subject reference, predicate reference, and object reference like in the following: .. code-block:: python from curies import Reference from curies.database import get_reference_sa_column from sqlmodel import Field, Session, SQLModel, create_engine, select class Edge(SQLModel, table=True): id: int | None = Field(default=None, primary_key=True) subject: Reference = Field(sa_column=get_reference_sa_column()) predicate: Reference = Field(sa_column=get_reference_sa_column()) object: Reference = Field(sa_column=get_reference_sa_column()) e1 = Edge(subject="CHEBI:135122", predicate="skos:exactMatch", object="mesh:C073738") e2 = Edge(subject="CHEBI:135125", predicate="skos:exactMatch", object="mesh:C073260") engine = create_engine("sqlite://") SQLModel.metadata.create_all(engine) # Add edges to the database with Session(engine) as session: session.add_all([e1, e2]) session.commit() # Query for edges with a given subject, by string with Session(engine) as session: statement = select(Edge).where(Edge.subject == "CHEBI:135122") edges = session.exec(statement).all() # Query for edges with a given subject, by string with Session(engine) as session: statement = select(Edge).where( Edge.subject == Reference(prefix="CHEBI", identifier="135125") ) edges = session.exec(statement).all() If you want to have a field that has an optional reference, you can do it as expected using the same column type, such as for the ``author`` field below: .. code-block:: python class Edge(SQLModel, table=True): id: int | None = Field(default=None, primary_key=True) subject: Reference = Field(sa_column=get_reference_sa_column()) predicate: Reference = Field(sa_column=get_reference_sa_column()) object: Reference = Field(sa_column=get_reference_sa_column()) author: Reference | None = Field(sa_column=get_reference_sa_column()) If you want to have a field with a list of references, you can do it using :func:`get_reference_list_sa_column`: .. code-block:: python class Record(SQLModel, table=True): id: int | None = Field(default=None, primary_key=True) authors: list[Reference] = Field( default_factory=list, sa_column=get_reference_list_sa_column() ) This also works how you would expect if you don't use a default_factory or if you choose to make it optional ``list[Reference] | None``. ######################### Using :mod:`sqlalchemy` ######################### SQLAlchemy is a combine high- and mid-level database abstraction layer and object-relational mapping. It has more opportunities for configuration over SQLModel. The following example re-formulates the above example for SQLModel using the slightly more direct SQLAlchemy formulation: .. code-block:: python from curies import Reference from sqlalchemy import Column, Integer, String, create_engine from sqlalchemy.orm import DeclarativeBase, Session class Base(DeclarativeBase): pass class Edge(Base): __tablename__ = "edge" id = Column(Integer, primary_key=True) subject = get_reference_sa_column() predicate = get_reference_sa_column() object = get_reference_sa_column() e1 = Edge(subject="CHEBI:135122", predicate="skos:exactMatch", object="mesh:C073738") e2 = Edge(subject="CHEBI:135125", predicate="skos:exactMatch", object="mesh:C073260") engine = create_engine("sqlite://") Base.metadata.create_all(engine) # Add edges to the database with Session(engine) as session: session.add_all([e1, e2]) session.commit() # Query for edges with a given subject, by string with Session(engine) as session: statement = select(Edge).where(Edge.subject == "CHEBI:135122") edges = session.exec(statement).all() # Query for edges with a given subject, by string with Session(engine) as session: statement = select(Edge).where( Edge.subject == Reference(prefix="CHEBI", identifier="135125") ) edges = session.exec(statement).all() In the following example, SQLAlchemy is used with a composite column, where the prefix and identifier are given their own column, then a :class:`sqlalchemy.Composite` object is used to tell the ORM to map both the prefix and identifier together into a single column, that exposes an appropriate :class:`curies.Reference` class. .. code-block:: python from curies import Reference from sqlalchemy import Column, Integer, String, create_engine from sqlalchemy.orm import DeclarativeBase, Session class Base(DeclarativeBase): pass class Edge(Base): __tablename__ = "edge" id = Column(Integer, primary_key=True) subject_prefix = Column(String, nullable=False) subject_identifier = Column(String, nullable=False) predicate_prefix = Column(String, nullable=False) predicate_identifier = Column(String, nullable=False) object_prefix = Column(String, nullable=False) object_identifier = Column(String, nullable=False) subject = get_reference_sa_composite(subject_prefix, subject_identifier) predicate = get_reference_sa_composite(predicate_prefix, predicate_identifier) object = get_reference_sa_composite(object_prefix, object_identifier) e1 = Edge(subject="CHEBI:135122", predicate="skos:exactMatch", object="mesh:C073738") e2 = Edge(subject="CHEBI:135125", predicate="skos:exactMatch", object="mesh:C073260") engine = create_engine("sqlite://") Base.metadata.create_all(engine) # Add edges to the database with Session(engine) as session: session.add_all([e1, e2]) session.commit() # Query for edges with a given subject, by string with Session(engine) as session: statement = select(Edge).where(Edge.subject == "CHEBI:135122") edges = session.exec(statement).all() # Query for edges with a given subject, by string with Session(engine) as session: statement = select(Edge).where( Edge.subject == Reference(prefix="CHEBI", identifier="135125") ) edges = session.exec(statement).all() Similarly to above, lists can be constructed using :func:`get_reference_list_sa_column`: .. code-block:: python class Record(Base): __tablename__ = "record" id = Column(Integer, primary_key=True) authors = get_reference_list_sa_column() """ from __future__ import annotations from typing import Any, ClassVar import sqlalchemy from sqlalchemy import Column from sqlalchemy.engine.interfaces import Dialect from sqlalchemy.orm import Composite, composite from sqlalchemy.sql.type_api import TypeEngine from sqlalchemy.types import JSON, TEXT, TypeDecorator from curies import Prefix, Reference __all__ = [ "SAReferenceListTypeDecorator", "SAReferenceTypeDecorator", "get_reference_list_sa_column", "get_reference_sa_column", "get_reference_sa_composite", ] class SAReferenceListTypeDecorator(TypeDecorator[list[Reference]]): """A SQLAlchemy type decorator for a list of :mod:`curies.Reference`.""" impl: ClassVar[type[TypeEngine[str]]] = JSON # type:ignore[misc] #: Set SQLAlchemy caching to true cache_ok: ClassVar[bool] = True # type:ignore[misc] def process_bind_param( self, value: str | Reference | list[Reference] | None, dialect: Dialect ) -> list[str] | None: """Convert the Python object into a database value.""" if value is None: return None if isinstance(value, str): return [value] elif isinstance(value, Reference): return [value.curie] else: return [v.curie for v in value] def process_result_value( self, value: list[str] | None, dialect: Dialect ) -> list[Reference] | None: """Convert the database value into a Python object.""" if value is None: return None return [Reference.from_curie(v) for v in value] class SAReferenceTypeDecorator(TypeDecorator[Reference]): """A SQLAlchemy type decorator for a :mod:`curies.Reference`.""" impl: ClassVar[type[TypeEngine[str]]] = TEXT # type:ignore[misc] #: Set SQLAlchemy caching to true cache_ok: ClassVar[bool] = True # type:ignore[misc] def process_bind_param(self, value: str | Reference | None, dialect: Dialect) -> str | None: """Convert the Python object into a database value.""" if value is None: return None if isinstance(value, str): return value return value.curie def process_result_value(self, value: str | None, dialect: Dialect) -> Reference | None: """Convert the database value into a Python object.""" if value is None: return None return Reference.from_curie(value) # TODO what about process literal param? def get_reference_sa_column(*args: Any, **kwargs: Any) -> sqlalchemy.Column[Reference]: """Get a SQLAlchemy column with the type decorator for a :mod:`curies.Reference`. :param args: positional arguments, passed to :class:`sqlalchemy.Column` :param kwargs: keyword arguments, passed to :class:`sqlalchemy.Column` :returns: A column object, parametrized with :class:`curies.Reference` For example, this can be used to model a semantic triple, which has a subject reference, predicate reference, and object reference like in the following: .. code-block:: python from curies import Reference from curies.database import get_reference_sa_column from sqlmodel import Field, SQLModel class Edge(SQLModel, table=True): id: int | None = Field(default=None, primary_key=True) subject: Reference = Field(sa_column=get_reference_sa_column()) predicate: Reference = Field(sa_column=get_reference_sa_column()) object: Reference = Field(sa_column=get_reference_sa_column()) """ return sqlalchemy.Column(SAReferenceTypeDecorator(), *args, **kwargs) def get_reference_list_sa_column(*args: Any, **kwargs: Any) -> sqlalchemy.Column[list[Reference]]: """Get a SQLAlchemy column with the type decorator for a :list of mod:`curies.Reference`. :param args: positional arguments, passed to :class:`sqlalchemy.Column` :param kwargs: keyword arguments, passed to :class:`sqlalchemy.Column` :returns: A column object, parametrized with list of :class:`curies.Reference` For example, this can be used to model an author list like in the following: .. code-block:: python from curies import Reference from curies.database import get_reference_list_sa_column from sqlmodel import Field, SQLModel class Edge(SQLModel, table=True): id: int | None = Field(default=None, primary_key=True) authors: list[Reference] = Field( default_factory=list, sa_column=get_reference_list_sa_column() ) """ return sqlalchemy.Column(SAReferenceListTypeDecorator(), *args, **kwargs) class _ReferenceAdapter(Reference): """A wrapper for SQLAlchemy for usage in composite().""" def __init__(self, prefix: str, identifier: str) -> None: """Initialize the SQLAlchemy model.""" super().__init__(prefix=Prefix(prefix), identifier=identifier) def get_reference_sa_composite( prefix_column: Column[str], identifier_column: Column[str], **kwargs: Any ) -> Composite[Reference]: """Get a composite for a reference. :param prefix_column: The column for the reference's prefix :param identifier_column: The column for the reference's identifier :param kwargs: keyword arguments passed to :func:`sqlalchemy.orm.composite` :returns: A Composite object for a reference .. code-block:: python from curies import Reference from curies.database import get_reference_sa_composite from sqlalchemy import Column from sqlalchemy.orm import DeclarativeBase class Base(DeclarativeBase): pass class Edge(Base): __tablename__ = "edge" id = Column(Integer, primary_key=True) subject_prefix = Column(String, nullable=False) subject_identifier = Column(String, nullable=False) predicate_prefix = Column(String, nullable=False) predicate_identifier = Column(String, nullable=False) object_prefix = Column(String, nullable=False) object_identifier = Column(String, nullable=False) subject = get_reference_sa_composite(subject_prefix, subject_identifier) predicate = get_reference_sa_composite(predicate_prefix, predicate_identifier) object = get_reference_sa_composite(object_prefix, object_identifier) """ return composite(_ReferenceAdapter, prefix_column, identifier_column, **kwargs) biopragmatics-curies-aa8bd37/src/curies/dataframe.py000066400000000000000000000322221525104130300226730ustar00rootroot00000000000000"""Dataframe operations.""" from __future__ import annotations from collections import defaultdict from collections.abc import Callable, Collection from typing import TYPE_CHECKING, Any, Literal, TypeAlias, TypeGuard, Union, cast from .utils import _prefix_from_curie if TYPE_CHECKING: import pandas as pd from .api import Converter __all__ = [ "PrefixIndexMethod", "filter_df_by_curies", "filter_df_by_prefixes", "get_df_curies_index", "get_df_prefixes_index", "get_df_unique_prefixes", "get_filter_df_by_curies_index", "get_filter_df_by_prefixes_index", ] DataframeOrSeries: TypeAlias = Union["pd.DataFrame", "pd.Series[str]"] def _get_prefix_checker(prefix: str | Collection[str]) -> Callable[[str], bool]: """Get a function that checks if a CURIE starts with a prefix.""" if isinstance(prefix, str): prefix_with_colon = prefix + ":" def _func(curie: str) -> bool: return curie.startswith(prefix_with_colon) else: prefixes_with_colons = {p + ":" for p in prefix} def _func(curie: str) -> bool: return any( curie.startswith(prefix_with_colon) for prefix_with_colon in prefixes_with_colons ) return _func def _get_prefixes_from_curie_column( df: DataframeOrSeries, *, column: int | str | None = None, converter: Converter | None = None, validate: bool, ) -> pd.Series[str]: return _get_series(df, column).map(_get_curie_parser(converter=converter, validate=validate)) def _get_curie_parser( *, converter: Converter | None = None, validate: bool = False ) -> Callable[[str], str]: # TODO what if it can't parse? # TODO handle None? # TODO handle invalid CURIEs? if not validate: return _prefix_from_curie elif converter is None: raise ValueError("converter is required for validation") else: def _func(curie: str) -> str: reference = converter.parse_curie(curie, strict=True) return reference.prefix return _func #: The method for filtering on prefixe PrefixIndexMethod: TypeAlias = Literal["iterative", "precalculated"] def get_filter_df_by_prefixes_index( df: DataframeOrSeries, *, column: str | int | None = None, prefixes: str | Collection[str], method: PrefixIndexMethod | None = None, validate: bool = False, converter: Converter | None = None, ) -> pd.Series[bool]: """Get an index of CURIEs in the given column that start with the prefix(es). :param df: A dataframe or series. If a dataframe is given, the ``column`` must not be none. :param column: The column to check, if a dataframe was passed. If a series was passed, this can be left as none. :param prefixes: The prefix or set of prefixes to identify :param method: The indexing method :param validate: Should the prefixes be validated against the converter? :param converter: A converter for validating CURIEs :returns: A pandas boolean series that corresponds to the rows of the dataframe or series provided :raises ValueError: If validation is set to true but no converter is passed Example usage: .. code-block:: python import pandas as pd from curies.dataframe import get_filter_df_by_prefixes_index rows = [ ("DOID:0080795", "skos:exactMatch", "EFO:0003029", "semapv:ManualMappingCuration"), ("DOID:0080795", "skos:exactMatch", "mesh:D015471", "semapv:ManualMappingCuration"), ("DOID:0080799", "skos:exactMatch", "EFO:1000527", "semapv:ManualMappingCuration"), ( "DOID:0080808", "skos:exactMatch", "mesh:D000069295", "semapv:ManualMappingCuration", ), ] df = pd.DataFrame( rows, columns=["subject_id", "predicate_id", "object_id", "mapping_justification"] ) idx = get_filter_df_by_prefixes_index(df, column="object_id", prefixes=["EFO"]) filtered_df = df[idx] """ if method == "iterative" or method is None: return _get_series(df, column).map(_get_prefix_checker(prefixes)) elif method == "precalculated": if converter is None: # pragma: no cover raise ValueError("a converter is required for method B") prefix_series = _get_prefixes_from_curie_column( df, column=column, converter=converter, validate=validate ) if isinstance(prefixes, str): return prefix_series == prefixes else: return prefix_series.isin(prefixes) else: # pragma: no cover raise ValueError(f"invalid method given: {method}") def filter_df_by_prefixes( df: pd.DataFrame, *, column: str | int, prefixes: str | Collection[str], method: PrefixIndexMethod | None = None, validate: bool = False, converter: Converter | None = None, ) -> pd.DataFrame: """Filter a dataframe based on CURIEs in a given column having a given prefix or set of prefixes. :param df: A dataframe :param column: The integer index or column name of a column containing CURIEs :param prefixes: The prefix (given as a string) or collection of prefixes (given as a list, set, etc.) to keep :param method: The implementation for getting the prefix index :param validate: Should the prefixes be validated against the converter? :param converter: A converter for validating CURIEs :returns: If not in place, return a new dataframe. Example usage: .. code-block:: python import pandas as pd from curies.dataframe import filter_df_by_prefixes rows = [ ("DOID:0080795", "skos:exactMatch", "EFO:0003029", "semapv:ManualMappingCuration"), ("DOID:0080795", "skos:exactMatch", "mesh:D015471", "semapv:ManualMappingCuration"), ("DOID:0080799", "skos:exactMatch", "EFO:1000527", "semapv:ManualMappingCuration"), ( "DOID:0080808", "skos:exactMatch", "mesh:D000069295", "semapv:ManualMappingCuration", ), ] df = pd.DataFrame( rows, columns=["subject_id", "predicate_id", "object_id", "mapping_justification"] ) filtered_df = filter_df_by_prefixes(df, column="object_id", prefixes=["EFO"]) This results in the following dataframe: ============ =============== =========== ============================ subject_id predicate_id object_id mapping_justification ============ =============== =========== ============================ DOID:0080795 skos:exactMatch EFO:0003029 semapv:ManualMappingCuration DOID:0080799 skos:exactMatch EFO:1000527 semapv:ManualMappingCuration ============ =============== =========== ============================ Internally, this function uses :func:`get_filter_df_by_prefixes_index`. """ idx = get_filter_df_by_prefixes_index( df=df, column=column, prefixes=prefixes, method=method, converter=converter, validate=validate, ) return df[idx] def get_filter_df_by_curies_index( df: DataframeOrSeries, *, column: str | int | None = None, curies: str | Collection[str], ) -> pd.Series[bool]: """Get an index of CURIEs in the given column that are the given CURIE(s).""" series = _get_series(df, column) if isinstance(curies, str): return series == curies else: return series.isin(set(curies)) def get_df_curies_index( df: DataframeOrSeries, *, column: str | int | None = None ) -> dict[str, list[int]]: """Get a dictionary from CURIEs that appear in the column to the row indexes where they appear.""" dd: defaultdict[str, list[int]] = defaultdict(list) for i, curie in enumerate(_get_series(df, column)): dd[curie].append(i) return dict(dd) def filter_df_by_curies( df: pd.DataFrame, *, column: str | int, curies: str | Collection[str], ) -> pd.DataFrame: """Filter a dataframe based on CURIEs in a given column having a given prefix or set of prefixes. :param df: A dataframe :param column: The integer index or column name of a column containing CURIEs :param curies: The CURIE (given as a string) or collection of CURIEs (given as a list, set, etc.) to keep :returns: If not in place, return a new dataframe. Example usage: .. code-block:: python import pandas as pd from curies.dataframe import filter_df_by_curies rows = [ ("DOID:0080795", "skos:exactMatch", "EFO:0003029", "semapv:ManualMappingCuration"), ("DOID:0080795", "skos:exactMatch", "mesh:D015471", "semapv:ManualMappingCuration"), ("DOID:0080799", "skos:exactMatch", "EFO:1000527", "semapv:ManualMappingCuration"), ( "DOID:0080808", "skos:exactMatch", "mesh:D000069295", "semapv:ManualMappingCuration", ), ] df = pd.DataFrame( rows, columns=["subject_id", "predicate_id", "object_id", "mapping_justification"] ) filtered_df = filter_df_by_curies(df, column="subject_id", prefixes=["DOID:0080795"]) This results in the following dataframe: ============ =============== ============ ============================ subject_id predicate_id object_id mapping_justification ============ =============== ============ ============================ DOID:0080795 skos:exactMatch EFO:0003029 semapv:ManualMappingCuration DOID:0080795 skos:exactMatch mesh:D015471 semapv:ManualMappingCuration ============ =============== ============ ============================ """ idx = get_filter_df_by_curies_index(df=df, column=column, curies=curies) return df[idx] def get_df_prefixes_index( df: DataframeOrSeries, *, column: str | int | None = None, converter: Converter | None = None, validate: bool = False, ) -> dict[str, list[int]]: """Get a dictionary from prefixes that appear in the column to the row indexes where they appear.""" dd: defaultdict[str, list[int]] = defaultdict(list) f = _get_curie_parser(converter=converter, validate=validate) for i, prefix in enumerate(_get_series(df, column).map(f)): dd[prefix].append(i) return dict(dd) def get_df_unique_prefixes( df: DataframeOrSeries, *, column: str | int | None = None, validate: bool = False, converter: Converter | None = None, ) -> set[str]: """Get unique prefixes. :param df: A dataframe or series. If a dataframe is given, the ``column`` must not be none. :param column: The column to check, if a dataframe was passed. If a series was passed, this can be left as none. :param validate: Should the prefixes be validated against the converter? :param converter: A converter for validating CURIEs :returns: A set of prefixes appearing in CURIEs in the given column .. code-block:: python import pandas as pd from curies.dataframe import get_df_unique_prefixes rows = [ ("DOID:0080795", "skos:exactMatch", "EFO:0003029", "semapv:ManualMappingCuration"), ("DOID:0080795", "skos:exactMatch", "mesh:D015471", "semapv:ManualMappingCuration"), ("DOID:0080799", "skos:exactMatch", "EFO:1000527", "semapv:ManualMappingCuration"), ( "DOID:0080808", "skos:exactMatch", "mesh:D000069295", "semapv:ManualMappingCuration", ), ] df = pd.DataFrame( rows, columns=["subject_id", "predicate_id", "object_id", "mapping_justification"] ) assert get_df_unique_prefixes(df, column="object_id") == {"EFO", "mesh"} """ series = _get_series(df, column) f = _get_curie_parser(converter=converter, validate=validate) return set(series.map(f).unique()) def _disallowed_dtype(series: pd.Series[Any] | str) -> TypeGuard[pd.Series[str]]: import numpy as np import pandas if isinstance(series, str): return False # pandas 3.0 introduced a new datatype - this code implicitly # checks if we're using pandas 3.0 if pandas.StringDtype is available if (string_dtype := getattr(pandas, "StringDtype", None)) and isinstance( series.dtype, string_dtype ): return False return series.dtype != np.str_ and series.dtype != np.dtype("O") def _get_series(df_or_series: DataframeOrSeries, column: str | int | None = None) -> pd.Series[str]: import pandas as pd if isinstance(df_or_series, pd.Series): if _disallowed_dtype(df_or_series): raise TypeError( f"passed series that does not have strings: {df_or_series.dtype=} {type(df_or_series.dtype)=}\n\n{df_or_series}" ) return df_or_series # ty:ignore if column is None: raise ValueError("must pass non-none column when using a dataframe directly") series = df_or_series[column] if _disallowed_dtype(series): raise TypeError( f"passed series that does not have strings: {series.dtype=} {type(series.dtype)=}\n\n{series}" ) return cast("pd.Series[str]", series) biopragmatics-curies-aa8bd37/src/curies/discovery.py000066400000000000000000000260721525104130300227640ustar00rootroot00000000000000"""Discovery new entries for a Converter. The :func:`curies.discover` functionality is intended to be used in a "data science" workflow. Its goal is to enable a data scientist to semi-interactively explore data (e.g., coming from an ontology, SSSOM, RDF) that doesn't come with a complete (extended) prefix map and identify common URI prefixes. It returns the discovered URI prefixes in a :class:`curies.Converter` object with "dummy" CURIE prefixes. This makes it possible to convert the URIs appearing in the data into CURIEs and therefore enables their usage in places where CURIEs are expected. However, it's suggested that after discovering URI prefixes, the data scientist more carefully constructs a meaningful prefix map based on the discovered one. This might include some or all of the following steps: 1. Replace dummy CURIE prefixes with meaningful ones 2. Remove spurious URI prefixes that appear but do not represent a semantic space. This happens often due to using ``_`` as a delimiter or having a frequency cutoff of zero (see the parameters for this function). 3. Consider chaining a comprehensive extended prefix map such as the Bioregistry (from :func:`curies.get_bioregistry_converter`) with onto the converter passed to this function so pre-existing URI prefixes are not *re-discovered*. Finally, you should save the prefix map that you create in a persistent place (i.e., inside a JSON file) such that it can be reused. ########### Algorithm ########### The :func:`curies.discover` function implements the following algorithm that does the following for each URI: 1. For each delimiter (in the priority order they are given) check if the delimiter is present. 2. If it's present, split the URI into two parts based on rightmost appearance of the delimiter. 3. If the right part after splitting is all alphanumeric characters, save the URI prefix (with delimiter attached) 4. If a delimiter is successfully used to identify a URI prefix, don't check any of the following delimiters After identifying putative URI prefixes, the second part of the algorithm does the following: 1. If a cutoff was provided, remove all putative URI prefixes for which there were fewer examples than the cutoff 2. Sort the URI prefixes lexicographically (i.e., with :func:`sorted`) 3. Assign a dummy CURIE prefix to each URI prefix, counting upwards from 1 4. Construct a converter from this prefix map and return it """ from __future__ import annotations from collections import defaultdict from collections.abc import Iterable, Mapping, Sequence from pathlib import PurePath from typing import IO, TYPE_CHECKING, Any, Literal, TextIO from curies import Converter, Record if TYPE_CHECKING: import rdflib import rdflib.parser GraphInput = IO[bytes] | TextIO | rdflib.parser.InputSource | str | bytes | PurePath __all__ = [ "discover", "discover_from_rdf", ] GraphFormats = Literal["turtle", "xml", "n3", "nt", "trix"] def discover_from_rdf( graph: GraphInput | rdflib.Graph, *, format: GraphFormats | None = None, **kwargs: Any, ) -> Converter: """Discover new URI prefixes from RDF content via :mod:`rdflib`. This function works the same as :func:`discover`, but gets its URI list from a triple store. See :func:`discover` for a more detailed explanation of how this algorithm works. :param graph: Either a pre-instantiated RDFlib graph, or an input type to the ``source`` keyword of :meth:`rdflib.Graph.parse`. This can be one of the following: - A string or bytes representation of a URL - A string, bytes, or Path representation of a local file - An I/O object that can be read directly - An open XML reader from RDFlib (:class:`rdflib.parser.InputSource`) :param format: If ``graph`` is given as a URL or I/O object, this is passed through to the ``format`` keyword of :meth:`rdflib.Graph.parse`. If none is given, defaults to ``turtle``. :param kwargs: Keyword arguments passed through to :func:`discover` :returns: A converter with dummy prefixes for URI prefixes appearing in the RDF content (i.e., triples). """ uris = get_uris_from_rdf(graph=graph, format=format) return discover(uris, **kwargs) def get_uris_from_rdf( graph: GraphInput | rdflib.Graph, *, format: GraphFormats | None = None ) -> set[str]: """Get a set of URIs from a graph.""" graph = _ensure_graph(graph=graph, format=format) return set(_yield_uris(graph=graph)) def _ensure_graph( *, graph: GraphInput | rdflib.Graph, format: GraphFormats | None = None ) -> rdflib.Graph: import rdflib if not isinstance(graph, rdflib.Graph): _temp_graph = rdflib.Graph() _temp_graph.parse(source=graph, format=format) graph = _temp_graph return graph def _yield_uris(*, graph: rdflib.Graph) -> Iterable[str]: import rdflib for parts in graph.triples((None, None, None)): for part in parts: if isinstance(part, rdflib.URIRef): yield str(part) def discover( uris: Iterable[str], *, delimiters: Sequence[str] | None = None, cutoff: int | None = None, metaprefix: str = "ns", converter: Converter | None = None, ) -> Converter: """Discover new URI prefixes and construct a converter with a unique dummy CURIE prefix for each. :param uris: An iterable of URIs to search through. Will be taken as a set and each unique entry is only considered once. :param delimiters: The character(s) that delimit a URI prefix from a local unique identifier. If none given, defaults to using ``/``, ``#``, and ``_``. For example: - ``/`` is the delimiter in ``https://www.ncbi.nlm.nih.gov/pubmed/37929212``, which separates the URI prefix ``https://www.ncbi.nlm.nih.gov/pubmed/`` from the local unique identifier `37929212 `_ for the article "New insights into osmobiosis and chemobiosis in tardigrades" in PubMed. - ``#`` is the delimiter in ``http://www.w3.org/2000/01/rdf-schema#label``, which separates the URI prefix ``http://www.w3.org/2000/01/rdf-schema#`` from the local unique identifier `label `_ for the term "label" in the RDF Schema. The ``#`` typically is used in a URL to denote a fragment and commonly appears in small semantic web vocabularies that are shown as a single HTML page. - ``_`` is the delimiter in ``http://purl.obolibrary.org/obo/GO_0032571``, which separates the URI prefix ``http://purl.obolibrary.org/obo/GO_`` from the local unique identifier `0032571 `_ for the term "response to vitamin K" in the Gene Ontology .. note:: The delimiter is itself a part of the URI prefix :param cutoff: If given, will require more than ``cutoff`` unique local unique identifiers associated with a given URI prefix to keep it. Defaults to zero, which increases recall (i.e., likelihood of getting all possible URI prefixes) but decreases precision (i.e., more of the results might be false positives / spurious). If you get a lot of false positives, try increasing first to 1, 2, then maybe higher. :param metaprefix: The beginning part of each dummy prefix, followed by a number. The default value is ``ns``, so dummy prefixes are named ``ns1``, ``ns2``, and so on. :param converter: If a pre-existing converter is passed, then URIs that can be parsed using the pre-existing converter are not considered during discovery. For example, if you're an OBO person working with URIs coming from an OBO ontology, it makes sense to pass the converter from :func:`curies.get_obo_converter` to reduce false positive discoveries. More generally, a comprehensive converter like the Bioregistry (from :func:`curies.get_bioregistry_converter`) can massively reduce false positive discoveries and ultimately reduce burden on the data scientist using this function when needing to understand the results and carefully curate a prefix map based on the discoveries. :returns: A converter with dummy prefixes >>> import curies >>> uris = [f"http://ran.dom/{i:03}" for i in range(30)] >>> discovered_converter = curies.discover(uris) >>> discovered_converter.records [Record(prefix="ns1", uri_prefix="http://ran.dom/", prefix_synonyms=[], uri_prefix_synonyms=[], pattern=None)] >>> discovered_converter.compress("http://ran.dom/002") 'ns1:002' """ uri_prefix_to_luids = _get_uri_prefix_to_luids( converter=converter, uris=uris, delimiters=delimiters ) uri_prefixes = [ uri_prefix for uri_prefix, luids in sorted(uri_prefix_to_luids.items()) # If the cutoff is 5, and only 3 unique LUIDs with the URI prefix # were identified, we're going to disregard this URI prefix. if cutoff is None or len(luids) >= cutoff ] records = [ Record(prefix=f"{metaprefix}{uri_prefix_index}", uri_prefix=uri_prefix) for uri_prefix_index, uri_prefix in enumerate(uri_prefixes, start=1) ] return Converter(records) #: The default delimiters used when guessing URI prefixes DEFAULT_DELIMITERS = ("#", "/", "_") def _get_uri_prefix_to_luids( *, converter: Converter | None = None, uris: Iterable[str], delimiters: Sequence[str] | None = None, ) -> Mapping[str, set[str]]: """Get a mapping from putative URI prefixes to corresponding putative local unique identifiers. :param converter: A converter with pre-existing definitions. URI prefixes are considered "new" if they can't already be validated by this converter :param uris: An iterable of URIs to search through. Will be taken as a set and each unique entry is only considered once. :param delimiters: The delimiters considered between a putative URI prefix and putative local unique identifier. By default, checks ``#`` first since this is commonly used for URL fragments, then ``/`` since many URIs are constructed with these. :returns: A dictionary of putative URI prefixes to sets of putative local unique identifiers """ if not delimiters: delimiters = DEFAULT_DELIMITERS uri_prefix_to_luids = defaultdict(set) for uri in uris: if converter is not None and converter.is_uri(uri): continue if uri.startswith("https://github.com") and "issues" in uri: # TODO it's not really the job of :mod:`curies` to incorporate special cases, # but the GitHub thing is such an annoyance... continue for delimiter in delimiters: if delimiter not in uri: continue uri_prefix, luid = uri.rsplit(delimiter, maxsplit=1) if luid.isalnum(): uri_prefix_to_luids[uri_prefix + delimiter].add(luid) break return dict(uri_prefix_to_luids) biopragmatics-curies-aa8bd37/src/curies/mapping_service/000077500000000000000000000000001525104130300235475ustar00rootroot00000000000000biopragmatics-curies-aa8bd37/src/curies/mapping_service/__init__.py000066400000000000000000000105071525104130300256630ustar00rootroot00000000000000"""Identifier mappings service. This contains an implementation of the service described in `SPARQL-enabled identifier conversion with Identifiers.org `_. The idea here is that you can write a SPARQL query like the following: .. code-block:: sparql PREFIX biomodel: PREFIX bqbio: PREFIX sbmlrdf: PREFIX up: SELECT DISTINCT ?protein ?protein_domain WHERE { # The first part of this query extracts the proteins appearing in an RDF serialization # of the BioModels database (see https://www.ebi.ac.uk/biomodels/BIOMD0000000372) on # insulin/glucose feedback. Note that modelers call entities appearing in compartmental # models "species", and this does not refer to taxa. biomodel:BIOMD0000000372 sbmlrdf:species/bqbio:isVersionOf ?biomodels_protein . # The second part of this query maps BioModels protein IRIs to UniProt protein IRIs # using service XXX - that's what we're implementing here. SERVICE { ?biomodels_protein owl:sameAs ?uniprot_protein. } # The third part of this query gets links between UniProt proteins and their # domains. Since the service maps between the BioModels query, this only gets # us relevant protein domains to the insulin/glucose model. SERVICE { ?uniprot_protein a up:Protein; up:organism taxon:9606; rdfs:seeAlso ?protein_domain. } } The SPARQL endpoint running at the web address XXX takes in the bound values for `?biomodels_protein` one at a time and dynamically generates triples with `owl:sameAs` as the predicate mapping and other equivalent IRIs (based on the definition of the converter) as the objects. This allows for gluing together multiple services that use different URIs for the same entities - in this example, there are two ways of referring to UniProt Proteins: 1. The BioModels database example represents a SBML model on insulin-glucose feedback and uses legacy Identifiers.org URIs for proteins such as http://identifiers.org/uniprot/P01308. 2. The first-part UniProt database uses its own PURLs such as https://purl.uniprot.org/uniprot/P01308. .. seealso:: - Jerven Bolleman's implementation of this service in Java: https://github.com/JervenBolleman/sparql-identifiers - Vincent Emonet's `SPARQL endpoint for RDFLib generator `_ The following is an end-to-end example of using this function to create a small URI mapping application. .. code-block:: python # flask_example.py from flask import Flask from curies import Converter, get_bioregistry_converter from curies.mapping_service import get_flask_mapping_app # Create a converter converter: Converter = get_bioregistry_converter() # Create the Flask app from the converter app: Flask = get_flask_mapping_app(converter) if __name__ == "__main__": app.run() In the command line, either run your Python file directly, or via with :mod:`gunicorn`: .. code-block:: console $ pip install gunicorn $ gunicorn --bind 0.0.0.0:8764 flask_example:app Test a request in the Python REPL. .. code-block:: python import requests sparql = "SELECT ?s ?o WHERE { VALUES ?s { } ?s owl:sameAs ?o }" res = requests.get("http://localhost:8764/sparql", params={"query": sparql}) Test a request using a service, e.g. with :meth:`rdflib.Graph.query` .. code-block:: sparql SELECT ?s ?o WHERE { VALUES ?s { } SERVICE { ?s owl:sameAs ?child_mapped . } } """ from .api import ( MappingServiceGraph, get_fastapi_mapping_app, get_fastapi_router, get_flask_mapping_app, get_flask_mapping_blueprint, ) from .rdflib_custom import MappingServiceSPARQLProcessor __all__ = [ "MappingServiceGraph", "MappingServiceSPARQLProcessor", "get_fastapi_mapping_app", "get_fastapi_router", "get_flask_mapping_app", "get_flask_mapping_blueprint", ] biopragmatics-curies-aa8bd37/src/curies/mapping_service/api.py000066400000000000000000000201521525104130300246720ustar00rootroot00000000000000"""Implementation of mapping service.""" from __future__ import annotations import itertools as itt from collections.abc import Collection, Iterable from typing import TYPE_CHECKING, Any from rdflib import OWL, Graph, URIRef from rdflib.term import _is_valid_uri from .rdflib_custom import MappingServiceSPARQLProcessor from .utils import CONTENT_TYPE_TO_RDFLIB_FORMAT, handle_header from ..api import Converter if TYPE_CHECKING: import fastapi import flask def _prepare_predicates(predicates: str | Collection[str] | None = None) -> set[URIRef]: if predicates is None: return {OWL.sameAs} if isinstance(predicates, str): return {URIRef(predicates)} return {URIRef(predicate) for predicate in predicates} class MappingServiceGraph(Graph): """A service that implements identifier mapping based on a converter.""" converter: Converter query_predicates: set[URIRef] def __init__( self, *args: Any, converter: Converter, predicates: str | list[str] | None = None, **kwargs: Any, ) -> None: """Instantiate the graph. :param args: Positional arguments to pass to :meth:`rdflib.Graph.__init__` :param converter: A converter object :param predicates: A predicate or set of predicates. If not given, this service will use `owl:sameAs` as a predicate for mapping IRIs. :param kwargs: Keyword arguments to pass to :meth:`rdflib.Graph.__init__` In the following example, a service graph is instantiated using a small example converter, then an example SPARQL query is made directly to show how it makes results: .. code-block:: python from curies import Converter from curies.mapping_service import CURIEServiceGraph converter = Converter.from_priority_prefix_map( { "CHEBI": [ "https://www.ebi.ac.uk/chebi/searchId.do?chebiId=", "http://identifiers.org/chebi/", "http://purl.obolibrary.org/obo/CHEBI_", ], "GO": ["http://purl.obolibrary.org/obo/GO_"], "OBO": ["http://purl.obolibrary.org/obo/"], # ... } ) graph = MappingServiceGraph(converter=converter) sparql = ( "SELECT ?o WHERE {" " VALUES ?s {" " " " }" " ?s owl:sameAs ?o" "}" ) res = graph.query(sparql) The results of this are: ====================================== ================================================= subject object http://purl.obolibrary.org/obo/CHEBI_1 http://purl.obolibrary.org/obo/CHEBI_1 http://purl.obolibrary.org/obo/CHEBI_1 http://identifiers.org/chebi/1 http://purl.obolibrary.org/obo/CHEBI_1 https://www.ebi.ac.uk/chebi/searchId.do?chebiId=1 ====================================== ================================================= """ self.converter = converter self.query_predicates = _prepare_predicates(predicates) super().__init__(*args, **kwargs) def _expand_pair_all(self, uri_in: str) -> list[URIRef]: reference = self.converter.parse_uri(uri_in) if reference is None: return [] uris = self.converter.expand_pair_all(reference.prefix, reference.identifier, strict=True) # do _is_valid_uri check because some configurations e.g. from Bioregistry might # produce invalid URIs e.g., containing spaces return [URIRef(uri) for uri in uris if _is_valid_uri(uri)] def triples( # type:ignore self, triple: tuple[URIRef | None, URIRef | None, URIRef | None] ) -> Iterable[tuple[URIRef, URIRef, URIRef]]: """Generate triples, overriden to dynamically generate mappings based on this graph's converter.""" subj_query, pred_query, obj_query = triple if pred_query in self.query_predicates: if subj_query is None and obj_query is not None: subjects = self._expand_pair_all(obj_query) for subj, pred in itt.product(subjects, self.query_predicates): yield subj, pred, obj_query elif subj_query is not None: objects = self._expand_pair_all(subj_query) if obj_query is None: for obj, pred in itt.product(objects, self.query_predicates): yield subj_query, pred, obj elif obj_query in objects: yield subj_query, pred_query, obj_query def get_flask_mapping_blueprint( converter: Converter, route: str = "/sparql", **kwargs: Any ) -> flask.Blueprint: """Get a blueprint for :class:`flask.Flask`. :param converter: A converter :param route: The route of the SPARQL service (relative to the base of the Blueprint) :param kwargs: Keyword arguments passed through to :class:`flask.Blueprint` :returns: A blueprint """ from flask import Blueprint, Response, request blueprint = Blueprint("mapping", __name__, **kwargs) graph = MappingServiceGraph(converter=converter) processor = MappingServiceSPARQLProcessor(graph=graph) # type:ignore[no-untyped-call] @blueprint.route(route, methods=["GET", "POST"]) def serve_sparql() -> Response: """Run a SPARQL query and serve the results.""" sparql = request.values.get("query") if not sparql: return Response( "Missing query (either in args for GET requests, or in form for POST requests)", 400 ) content_type = handle_header(request.headers.get("accept")) results = graph.query(sparql, processor=processor) response = results.serialize(format=CONTENT_TYPE_TO_RDFLIB_FORMAT[content_type]) return Response(response, content_type=content_type) return blueprint def get_fastapi_router( converter: Converter, route: str = "/sparql", **kwargs: Any ) -> fastapi.APIRouter: """Get a router for :class:`fastapi.FastAPI`. :param converter: A converter :param route: The route of the SPARQL service (relative to the base of the API router) :param kwargs: Keyword arguments passed through to :class:`fastapi.APIRouter` :returns: A router """ from fastapi import APIRouter, Form, Header, Query, Response api_router = APIRouter(**kwargs) graph = MappingServiceGraph(converter=converter) processor = MappingServiceSPARQLProcessor(graph=graph) # type:ignore[no-untyped-call] def _resolve(accept: str, sparql: str) -> Response: content_type = handle_header(accept) results = graph.query(sparql, processor=processor) response = results.serialize(format=CONTENT_TYPE_TO_RDFLIB_FORMAT[content_type]) return Response(response, media_type=content_type) @api_router.get(route) def resolve_get( query: str = Query(description="The SPARQL query to run"), accept: str = Header(), ) -> Response: """Run a SPARQL query and serve the results.""" return _resolve(accept, query) @api_router.post(route) def resolve_post( query: str = Form(description="The SPARQL query to run"), accept: str = Header(), ) -> Response: """Run a SPARQL query and serve the results.""" return _resolve(accept, query) return api_router def get_flask_mapping_app(converter: Converter) -> flask.Flask: """Get a Flask app for the mapping service.""" from flask import Flask blueprint = get_flask_mapping_blueprint(converter) app = Flask(__name__) app.register_blueprint(blueprint) return app def get_fastapi_mapping_app(converter: Converter) -> fastapi.FastAPI: """Get a FastAPI app. :param converter: A converter :returns: A FastAPI app """ from fastapi import FastAPI router = get_fastapi_router(converter) app = FastAPI() app.include_router(router) return app biopragmatics-curies-aa8bd37/src/curies/mapping_service/rdflib_custom.py000066400000000000000000000070351525104130300267620ustar00rootroot00000000000000"""A custom SPARQL processor that optimizes the query based on https://github.com/RDFLib/rdflib/pull/2257.""" from __future__ import annotations from collections.abc import Mapping from typing import Any from rdflib.plugins.sparql.algebra import translateQuery from rdflib.plugins.sparql.evaluate import evalQuery from rdflib.plugins.sparql.parser import parseQuery from rdflib.plugins.sparql.parserutils import CompValue from rdflib.plugins.sparql.processor import SPARQLProcessor from rdflib.plugins.sparql.sparql import Query from rdflib.term import Identifier __all__ = ["MappingServiceSPARQLProcessor"] class MappingServiceSPARQLProcessor(SPARQLProcessor): """A custom SPARQL processor that optimizes the query based on https://github.com/RDFLib/rdflib/pull/2257. Why is this necessary? Ideally, we get queries like .. code-block:: sparql SELECT * WHERE { VALUES ?s { :a :b ... } ?s owl:sameAs ?o } This is fine, since the way that RDFLib parses and constructs an abstract syntax tree, the values for ``?s`` get bound properly when calling a custom :func:`rdflib.Graph.triples`. However, it's also valid SPARQL to have the ``VALUES`` clause outside of the ``WHERE`` clause like .. code-block:: sparql SELECT * WHERE { ?s owl:sameAs ?o } VALUES ?s { :a :b ... } Unfortunately, this trips up RDFLib since it doesn't know to bind the values before calling ``triples()``, therefore thwarting our custom implementation that dynamically generates triples based on the bound values themselves. This processor, originally by Jerven Bolleman in https://github.com/RDFLib/rdflib/pull/2257, adds some additional logic between parsing + constructing the abstract syntax tree and evaluation of the syntax tree. Basically, the abstract syntax tree has nodes with two or more children. Jerven's clever code (see :func:`_optimize_node` below) finds *Join* nodes that have a ``VALUES`` clause in the second of its two arguments, then flips them around. It does this recursively for the whole tree. This gets us to the goal of having the ``VALUES`` clauses appear first, therefore making sure that their bound values are available to the ``triples`` function. """ def query( # type:ignore[override] self, strOrQuery: str | Query, # noqa:N803 initBindings: Mapping[str, Identifier] | None = None, # noqa:N803 initNs: Mapping[str, Any] | None = None, # noqa:N803 base: str | None = None, DEBUG: bool = False, # noqa:N803 ) -> Mapping[Any, Any]: """Evaluate a SPARQL query on this processor's graph.""" if isinstance(strOrQuery, str): parse_tree = parseQuery(strOrQuery) str_or_qury = translateQuery(parse_tree, base, initNs) return self.query(str_or_qury, initBindings=initBindings, base=base) strOrQuery.algebra = _optimize_node(strOrQuery.algebra) return evalQuery(self.graph, strOrQuery, initBindings or {}, base) # From Jerven's PR to RDFLib (https://github.com/RDFLib/rdflib/pull/2257) def _optimize_node(comp_value: CompValue) -> CompValue: if ( comp_value.name == "Join" and comp_value.p1.name != "ToMultiSet" and comp_value.p2.name == "ToMultiSet" ): comp_value.update(p1=comp_value.p2, p2=comp_value.p1) for inner_comp_value in comp_value.values(): if isinstance(inner_comp_value, CompValue): _optimize_node(inner_comp_value) return comp_value biopragmatics-curies-aa8bd37/src/curies/mapping_service/utils.py000066400000000000000000000115331525104130300252640ustar00rootroot00000000000000"""Utilities for the mapping service.""" from __future__ import annotations import csv import json import json.decoder import unittest from collections.abc import Callable, Iterable, Mapping from xml.etree.ElementTree import Element from defusedxml import ElementTree __all__ = [ "CONTENT_TYPE_TO_HANDLER", "get_sparql_records", "handle_csv", "handle_header", "handle_json", "handle_xml", "parse_header", "sparql_service_available", ] Record = Mapping[str, str] Records = list[Record] #: A SPARQL query used to ping a SPARQL endpoint PING_SPARQL = 'SELECT ?s ?o WHERE { BIND("hello" as ?s) . BIND("there" as ?o) . }' #: This is default for federated queries DEFAULT_CONTENT_TYPE = "application/sparql-results+xml" #: A mapping from content types to the keys used for serializing #: in :meth:`rdflib.Graph.serialize` and other serialization functions CONTENT_TYPE_TO_RDFLIB_FORMAT = { # https://www.w3.org/TR/sparql11-results-json/ "application/sparql-results+json": "json", # https://www.w3.org/TR/rdf-sparql-XMLres/ "application/sparql-results+xml": "xml", # https://www.w3.org/TR/sparql11-results-csv-tsv/ "application/sparql-results+csv": "csv", } #: A dictionary that maps synonym content types to the canonical ones CONTENT_TYPE_SYNONYMS = { "application/json": "application/sparql-results+json", "text/json": "application/sparql-results+json", "application/xml": "application/sparql-results+xml", "text/xml": "application/sparql-results+xml", "text/csv": "application/sparql-results+csv", } def handle_json(text: str) -> Records: """Parse bindings encoded in a JSON string.""" data = json.loads(text) return [ {key: value["value"] for key, value in record.items()} for record in data["results"]["bindings"] ] def handle_xml(text: str) -> Records: """Parse bindings encoded in an XML string.""" root = ElementTree.fromstring(text) results = root.find("{http://www.w3.org/2005/sparql-results#}results") if results is None: raise ValueError return [_handle_result(result) for result in results] def _handle_result(result: Iterable[Element]) -> Record: return { binding.attrib["name"]: value for binding in result if (value := binding.findtext("{http://www.w3.org/2005/sparql-results#}uri")) } def handle_csv(text: str) -> Records: """Parse bindings encoded in a CSV string.""" return list(csv.DictReader(text.splitlines())) #: A mapping from canonical content types to functions for parsing them CONTENT_TYPE_TO_HANDLER: Mapping[str, Callable[[str], Records]] = { "application/sparql-results+json": handle_json, "application/sparql-results+xml": handle_xml, "application/sparql-results+csv": handle_csv, } def get_sparql_records(endpoint: str, sparql: str, accept: str) -> Records: """Get a response from a given SPARQL query.""" import requests res = requests.get( endpoint, timeout=60, params={"query": sparql}, headers={"accept": accept}, ) res.raise_for_status() func = CONTENT_TYPE_TO_HANDLER[handle_header(accept)] return func(res.text) def get_sparql_record_so_tuples(records: Records) -> set[tuple[str, str]]: """Get subject/object pairs from records.""" return {(record["s"], record["o"]) for record in records} def sparql_service_available(endpoint: str) -> bool: """Test if a SPARQL service is running.""" try: records = get_sparql_records(endpoint, PING_SPARQL, "application/json") except (OSError, json.decoder.JSONDecodeError): return False return {("hello", "there")} == get_sparql_record_so_tuples(records) def _handle_part(part: str) -> tuple[str, float]: if ";q=" not in part: return part, 1.0 key, q = part.split(";q=", 1) return key, float(q) def parse_header(header: str) -> list[str]: """Parse the header and sort in descending order of q value.""" parts = dict(_handle_part(part) for part in header.split(",")) return sorted(parts, key=parts.__getitem__, reverse=True) def handle_header(header: str | None, default: str = DEFAULT_CONTENT_TYPE) -> str: """Canonicalize a header.""" if not header: return default for header_part in parse_header(header): header_part = CONTENT_TYPE_SYNONYMS.get(header_part, header_part) if header_part in CONTENT_TYPE_TO_RDFLIB_FORMAT: return header_part # What happens if encountering "*/*" that has a higher q than something else? # Is that even possible/coherent? return default def require_service( url: str, name: str ) -> Callable[[type[unittest.TestCase]], type[unittest.TestCase]]: """Skip a test unless the service is available.""" return unittest.skipUnless( sparql_service_available(url), reason=f"No {name} service is running on {url}" ) biopragmatics-curies-aa8bd37/src/curies/mixins.py000066400000000000000000000206671525104130300222700ustar00rootroot00000000000000"""Mixin classes.""" from __future__ import annotations from abc import ABC, abstractmethod from collections.abc import Iterable from typing import Generic, Literal, Self, TypeVar, overload from .api import Converter __all__ = [ "SemanticallyProcessable", "SemanticallyStandardizable", "process", "process_many", "standardize", "standardize_many", ] X = TypeVar("X") class SemanticallyProcessable(ABC, Generic[X]): """A class that can be processed with a converter. The goal of this class is to standardize objects that come with unprocessed URIs that can be processed into references with respect to a :class:`curies.Converter`. For example, this is useful for :mod:`obographs` and :mod:`jskos`. .. code-block:: python from pydantic import BaseModel from curies import SemanticallyProcessable class ProcessedEntity(BaseModel): reference: Reference class RawEntity(BaseModel, SemanticallyProcessable[ProcessedEntity]): uri: str def process(self, converter: Converter) -> ProcessedEntity: return ProcessedEntity( reference=converter.parse_uri(self.uri, strict=True).to_pydantic() ) :mod:`curies` provides a high-level interface for standardizing classes in :func:`curies.process`. .. code-block:: python from curies import Converter converter = Converter.from_prefix_map({"CHEBI": "http://purl.obolibrary.org/obo/CHEBI_"}) e1 = RawEntity(uri="http://purl.obolibrary.org/obo/CHEBI_1") e2 = RawEntity(uri="http://purl.obolibrary.org/obo/CHEBI_2") # can be used directly on an object assert ProcessedEntity(reference=Reference.from_curie("CHEBI:1")) == curies.standardize( e1, converter ) # can also be used on an iterable/collection assert [ ProcessedEntity(reference=Reference.from_curie("CHEBI:1")), ProcessedEntity(reference=Reference.from_curie("CHEBI:2")), ] == curies.process((e1, e2), converter) """ @abstractmethod def process(self, converter: Converter) -> X: """Process this raw instance.""" raise NotImplementedError # docstr-coverage:excused `overload` @overload def process(instances: None, converter: Converter, *, return_iterator: bool = ...) -> None: ... # docstr-coverage:excused `overload` @overload def process( instances: SemanticallyProcessable[X], converter: Converter, *, return_iterator: bool = ... ) -> X: ... # docstr-coverage:excused `overload` @overload def process( instances: Iterable[SemanticallyProcessable[X]], converter: Converter, *, return_iterator: Literal[False] = ..., ) -> list[X]: ... # docstr-coverage:excused `overload` @overload def process( instances: Iterable[SemanticallyProcessable[X]], converter: Converter, *, return_iterator: Literal[True] = ..., ) -> Iterable[X]: ... def process( instances: SemanticallyProcessable[X] | Iterable[SemanticallyProcessable[X]] | None, converter: Converter, *, return_iterator: bool = False, ) -> X | list[X] | Iterable[X] | None: """Process multiple semantically processable instances.""" if instances is None: return None elif isinstance(instances, Iterable): if return_iterator: return (instance.process(converter) for instance in instances) else: return [instance.process(converter) for instance in instances] else: return instances.process(converter) process_many = process class SemanticallyStandardizable(ABC): """An object that can be standardized. In the following example, a simple object is constructed: .. code-block:: python from typing import Self from curies import Converter, Reference, SemanticallyStandardizable class ReferenceHolder(SemanticallyStandardizable): def __init__(self, reference): self.reference = reference def standardize(self, converter: Converter) -> Self: return ReferenceHolder(converter.standardize_reference(self.reference, strict=True)) It's good form to make these operations return new objects, but there's no reason you couldn't update the object in place like in : .. code-block:: python from typing import Self from curies import Converter, Reference, SemanticallyStandardizable class ReferenceHolder(SemanticallyStandardizable): def __init__(self, reference): self.reference = reference def standardize(self, converter: Converter) -> Self: self.reference = converter.standardize_reference(self.reference, strict=True) return self In the following example, the :meth:`pydantic.BaseModel.model_copy` is used to automatically reuse all other fields that aren't updated, which creates a new object. .. code-block:: python import datetime from typing import Self from curies import Converter, Reference, SemanticallyStandardizable from pydantic import BaseModel class Triple(BaseModel, SemanticallyStandardizable): subject: Reference predicate: Reference object: Reference date_asserted: datetime.date def standardize(self, converter: Converter) -> Self: return self.model_copy( update={ "subject": converter.standardize_reference(self.subject, strict=True), "predicate": converter.standardize_reference(self.predicate, strict=True), "object": converter.standardize_reference(self.object, strict=True), } ) :mod:`curies` provides a high-level interface for standardizing classes in :func:`curies.standardize`. .. code-block:: python from curies import Converter converter = Converter() converter.add_prefix("CHEBI", "http://purl.obolibrary.org/obo/CHEBI_") converter.add_synonym("CHEBI", "chebi") r1 = ReferenceHolder(Reference.from_curie("chebi:1")) r2 = ReferenceHolder(Reference.from_curie("chebi:2")) # can be used directly on an object assert ReferenceHolder(Reference.from_curie("CHEBI:1")) == curies.standardize(r1, converter) # can also be used on an iterable/collection assert [ ReferenceHolder(Reference.from_curie("CHEBI:1")), ReferenceHolder(Reference.from_curie("CHEBI:2")), ] == curies.standardize((r1, r2), converter) """ @abstractmethod def standardize(self, converter: Converter) -> Self: """Standardize all references in the object.""" raise NotImplementedError SemanticallyStandardizableType = TypeVar( "SemanticallyStandardizableType", bound=SemanticallyStandardizable ) # docstr-coverage:excused `overload` @overload def standardize(instances: None, converter: Converter, *, return_iterator: bool = ...) -> None: ... # docstr-coverage:excused `overload` @overload def standardize( instances: SemanticallyStandardizableType, converter: Converter, *, return_iterator: bool = ... ) -> SemanticallyStandardizableType: ... # docstr-coverage:excused `overload` @overload def standardize( instances: Iterable[SemanticallyStandardizableType], converter: Converter, *, return_iterator: Literal[True] = ..., ) -> Iterable[SemanticallyStandardizableType]: ... # docstr-coverage:excused `overload` @overload def standardize( instances: Iterable[SemanticallyStandardizableType], converter: Converter, *, return_iterator: Literal[False] = ..., ) -> list[SemanticallyStandardizableType]: ... def standardize( instances: SemanticallyStandardizableType | Iterable[SemanticallyStandardizableType] | None, converter: Converter, *, return_iterator: bool = False, ) -> ( SemanticallyStandardizableType | Iterable[SemanticallyStandardizableType] | list[SemanticallyStandardizableType] | None ): """Standardize an instance.""" if instances is None: return None elif isinstance(instances, Iterable): if return_iterator: return (instance.standardize(converter) for instance in instances) else: return [instance.standardize(converter) for instance in instances] else: return instances.standardize(converter) standardize_many = standardize biopragmatics-curies-aa8bd37/src/curies/preprocessing.py000066400000000000000000000341641525104130300236410ustar00rootroot00000000000000"""Reusable configuration.""" from __future__ import annotations import json from collections.abc import Callable from pathlib import Path from typing import Any, Literal, Self, TypeAlias, TypeVar, overload from pydantic import BaseModel, Field from .api import Converter, Reference, ReferenceTuple, URIType __all__ = [ "BlockAction", "BlocklistError", "PostprocessingRewrites", "PreprocessingBlocklists", "PreprocessingConverter", "PreprocessingRewrites", "PreprocessingRules", ] #: The action taken when the blocklist is invoked BlockAction: TypeAlias = Literal["raise", "pass"] X = TypeVar("X", bound=Reference) class PreprocessingBlocklists(BaseModel): """A model for prefix and full blocklists.""" full: list[str] = Field(default_factory=list) resource_full: dict[str, list[str]] = Field(default_factory=dict) prefix: list[str] = Field(default_factory=list) resource_prefix: dict[str, list[str]] = Field(default_factory=dict) suffix: list[str] = Field(default_factory=list) def _sort(self) -> None: self.full.sort() self.prefix.sort() self.suffix.sort() for v in self.resource_full.values(): v.sort() for v in self.resource_prefix.values(): v.sort() def str_has_blocked_prefix( self, str_or_curie_or_uri: str, *, context: str | None = None ) -> bool: """Check if the CURIE string has a blocklisted prefix.""" if context: prefixes: list[str] = self.resource_prefix.get(context, []) if prefixes and any(str_or_curie_or_uri.startswith(prefix) for prefix in prefixes): return True return any(str_or_curie_or_uri.startswith(prefix) for prefix in self.prefix) def str_has_blocked_suffix(self, str_or_curie_or_uri: str) -> bool: """Check if the CURIE string has a blocklisted suffix.""" return any(str_or_curie_or_uri.endswith(suffix) for suffix in self.suffix) def str_is_blocked_full(self, str_or_curie_or_uri: str, *, context: str | None = None) -> bool: """Check if the full CURIE string is blocklisted.""" if context and str_or_curie_or_uri in self.resource_full.get(context, set()): return True return str_or_curie_or_uri in self.full def str_is_blocked(self, str_or_curie_or_uri: str, *, context: str | None = None) -> bool: """Check if the full CURIE string is blocklisted.""" return ( self.str_has_blocked_prefix(str_or_curie_or_uri, context=context) or self.str_has_blocked_suffix(str_or_curie_or_uri) or self.str_is_blocked_full(str_or_curie_or_uri, context=context) ) class PostprocessingRewrites(BaseModel): """A model for post-processing based on the prefix parsed.""" suffix: dict[str, list[str]] = Field(default_factory=dict) class PreprocessingRewrites(BaseModel): """A model for prefix and full rewrites.""" full: dict[str, str] = Field( default_factory=dict, description="Global remappings for an entire string" ) resource_full: dict[str, dict[str, str]] = Field( default_factory=dict, description="Resource-keyed remappings for an entire string" ) prefix: dict[str, str] = Field( default_factory=dict, description="Global remappings of just the prefix" ) resource_prefix: dict[str, dict[str, str]] = Field( default_factory=dict, description="Resource-keyed remappings for just a prefix" ) def remap_full( self, str_or_curie_or_uri: str, reference_cls: type[X], *, context: str | None = None, ) -> X | None: """Remap the string if possible otherwise return it.""" if context: resource_rewrites: dict[str, str] = self.resource_full.get(context, {}) if resource_rewrites and str_or_curie_or_uri in resource_rewrites: return reference_cls.from_curie(resource_rewrites[str_or_curie_or_uri]) if str_or_curie_or_uri in self.full: return reference_cls.from_curie(self.full[str_or_curie_or_uri]) return None def remap_prefix(self, str_or_curie_or_uri: str, *, context: str | None = None) -> str: """Remap a prefix.""" if context is not None: for old_prefix, new_prefix in self.resource_prefix.get(context, {}).items(): if str_or_curie_or_uri.startswith(old_prefix): return new_prefix + str_or_curie_or_uri[len(old_prefix) :] for old_prefix, new_prefix in self.prefix.items(): if str_or_curie_or_uri.startswith(old_prefix): return new_prefix + str_or_curie_or_uri[len(old_prefix) :] return str_or_curie_or_uri class PreprocessingRules(BaseModel): """A model for blocklists and rewrites.""" blocklists: PreprocessingBlocklists = Field(default_factory=PreprocessingBlocklists) rewrites: PreprocessingRewrites = Field(default_factory=PreprocessingRewrites) postprocessing: PostprocessingRewrites = Field(default_factory=PostprocessingRewrites) @classmethod def lint_file(cls, path: str | Path) -> None: """Lint a file, in place, given a file path.""" path = Path(path).expanduser().resolve() rules = cls.model_validate_json(path.read_text()) rules.blocklists._sort() path.write_text( json.dumps( rules.model_dump(exclude_unset=True, exclude_defaults=True), sort_keys=True, indent=2, ) ) def str_is_blocked(self, str_or_curie_or_uri: str, *, context: str | None = None) -> bool: """Check if the CURIE string is blocked.""" return self.blocklists.str_is_blocked(str_or_curie_or_uri, context=context) def remap_full( self, str_or_curie_or_uri: str, reference_cls: type[X], *, context: str | None = None, ) -> X | None: """Remap the string if possible otherwise return it.""" return self.rewrites.remap_full( str_or_curie_or_uri, reference_cls=reference_cls, context=context ) def remap_prefix(self, str_or_curie_or_uri: str, *, context: str | None = None) -> str: """Remap a prefix.""" return self.rewrites.remap_prefix(str_or_curie_or_uri, context=context) def _load_rules(rules: str | Path | PreprocessingRules) -> PreprocessingRules: # TODO load remote? if isinstance(rules, (str, Path)): rules = Path(rules).expanduser().resolve() rules = PreprocessingRules.model_validate_json(rules.read_text()) return rules class BlocklistError(ValueError): """An error for block list.""" def _identity(uri: URIType) -> str: return str(uri) class PreprocessingConverter(Converter): """A converter with pre-processing rules.""" def __init__( self, *args: Any, rules: PreprocessingRules | str | Path, reference_cls: type[X] | None = None, preclean: Callable[[URIType], str] | None = None, **kwargs: Any, ) -> None: """Instantiate a converter with a ruleset for pre-processing. :param args: Positional arguments passed to :meth:`curies.Converter.__init__` :param rules: A set of rules :param reference_cls: The reference class to use. Defaults to :class:`curies.Reference`. :param preclean: An optional function used to preprocess strings, CURIEs, and URIs before parsing :param kwargs: Keyword arguments passed to :meth:`curies.Converter.__init__` """ super().__init__(*args, **kwargs) self.rules = _load_rules(rules) self._reference_cls = Reference if reference_cls is None else reference_cls self._preclean = preclean if preclean is not None else _identity @classmethod def from_converter(cls, converter: Converter, rules: PreprocessingRules | str | Path) -> Self: """Wrap a converter with a ruleset. :param converter: A pre-instantiated converter :param rules: A pre-processing rules object, or path to a JSON file containing a pre-processing configuration :returns: A converter that uses the ruls for pre-processing when parsing URIs and CURIEs. """ return cls(records=converter.records, rules=rules) def _post_process(self, rt: ReferenceTuple | None) -> ReferenceTuple | None: if rt is None: return None if rt.prefix in self.rules.postprocessing.suffix: for s in self.rules.postprocessing.suffix[rt.prefix]: if rt.identifier.endswith(s): return ReferenceTuple( prefix=rt.prefix, identifier=rt.identifier.removesuffix(s) ) return rt # docstr-coverage:excused `overload` @overload def parse( self, str_or_uri_or_curie: str | URIType, *, strict: Literal[True] = True, context: str | None = ..., block_action: BlockAction = ..., ) -> ReferenceTuple: ... # docstr-coverage:excused `overload` @overload def parse( self, str_or_uri_or_curie: str | URIType, *, strict: Literal[False] = False, context: str | None = ..., block_action: BlockAction = ..., ) -> ReferenceTuple | None: ... def parse( self, str_or_uri_or_curie: str | URIType, *, strict: bool = False, context: str | None = None, block_action: BlockAction = "raise", ) -> ReferenceTuple | None: """Parse a string, CURIE, or URI.""" str_or_uri_or_curie = self._preclean(str_or_uri_or_curie) if r1 := self.rules.remap_full( str_or_uri_or_curie, reference_cls=self._reference_cls, context=context ): return r1.pair # Remap node's prefix (if necessary) str_or_uri_or_curie = self.rules.remap_prefix(str_or_uri_or_curie, context=context) if self.rules.str_is_blocked(str_or_uri_or_curie, context=context): if block_action == "raise": raise BlocklistError else: return None rv = super().parse(str_or_uri_or_curie, strict=strict) # type:ignore[call-overload] return self._post_process(rv) # docstr-coverage:excused `overload` @overload def parse_curie( self, curie: str, *, strict: Literal[False] = False, context: str | None = ..., block_action: BlockAction = ..., ) -> ReferenceTuple | None: ... # docstr-coverage:excused `overload` @overload def parse_curie( self, curie: str, *, strict: Literal[True] = True, context: str | None = ..., block_action: BlockAction = ..., ) -> ReferenceTuple: ... def parse_curie( self, curie: str, *, strict: bool = False, context: str | None = None, block_action: BlockAction = "raise", ) -> ReferenceTuple | None: """Parse and standardize a CURIE. :param curie: The CURIE to parse and standardize :param strict: If the CURIE can't be parsed, should an error be thrown? Defaults to false. :param context: Is there a context, e.g., an ontology prefix that should be applied to the remapping and blocklist rules? :param block_action: What action should be taken when the blocklist is invoked? - **raise** - raise an exception - **pass** - return ``None`` :returns: A tuple representing a parsed and standardized CURIE :raises BlocklistError: If the CURIE is blocked """ curie = self._preclean(curie) if r1 := self.rules.remap_full(curie, reference_cls=self._reference_cls, context=context): return r1.pair # Remap node's prefix (if necessary) curie = self.rules.remap_prefix(curie, context=context) if self.rules.str_is_blocked(curie, context=context): if block_action == "raise": raise BlocklistError else: return None rv = super().parse_curie(curie, strict=strict) # type:ignore[call-overload] return self._post_process(rv) # docstr-coverage:excused `overload` @overload def parse_uri( self, uri: URIType, *, strict: Literal[False] = ..., context: str | None = ..., block_action: BlockAction = ..., ) -> ReferenceTuple | None: ... # docstr-coverage:excused `overload` @overload def parse_uri( self, uri: URIType, *, strict: Literal[True] = True, context: str | None = ..., block_action: BlockAction = ..., ) -> ReferenceTuple: ... def parse_uri( self, uri: URIType, *, strict: bool = False, context: str | None = None, block_action: BlockAction = "raise", ) -> ReferenceTuple | None: """Parse and standardize a URI. :param uri: The URI to parse and standardize :param strict: If the URI can't be parsed, should an error be thrown? Defaults to false. :param context: Is there a context, e.g., an ontology prefix that should be applied to the remapping and blocklist rules? :param block_action: What action should be taken when the blocklist is invoked? - **raise** - raise an exception - **pass** - return ``None`` :returns: A tuple representing a parsed and standardized URI :raises BlocklistError: If the URI is blocked """ uri = self._preclean(uri) if r1 := self.rules.remap_full(uri, reference_cls=self._reference_cls, context=context): return r1.pair # Remap node's prefix (if necessary) uri = self.rules.remap_prefix(uri, context=context) if self.rules.str_is_blocked(uri, context=context): if block_action == "raise": raise BlocklistError else: return None rv: ReferenceTuple | None = super().parse_uri(uri, strict=strict) # type:ignore[call-overload] return self._post_process(rv) biopragmatics-curies-aa8bd37/src/curies/py.typed000066400000000000000000000000011525104130300220620ustar00rootroot00000000000000 biopragmatics-curies-aa8bd37/src/curies/reconciliation.py000066400000000000000000000227401525104130300237550ustar00rootroot00000000000000"""Reconciliation.""" from __future__ import annotations import logging from collections import Counter, defaultdict from collections.abc import Collection, Mapping from .api import Converter, Record __all__ = [ "remap_curie_prefixes", "remap_uri_prefixes", "rewire", ] logger = logging.getLogger(__name__) class TransitiveError(NotImplementedError): """An error when transitive mappings appear.""" def __init__(self, intersection: Collection[str]) -> None: """Initialize the exception. :param intersection: The strings that appeared both as keys and values in a remapping dictionary (either for CURIEs or URIs) """ self.intersection = intersection def __str__(self) -> str: return ( f"Transitive mapping has not been implemented. This is being thrown because " f"the following appear in both the keys and values of the remapping: {self.intersection}." "\n\nSee discussion at https://github.com/cthoyt/curies/issues/75." ) def remap_curie_prefixes(converter: Converter, remapping: Mapping[str, str]) -> Converter: """Apply CURIE prefix remappings. :param converter: A converter :param remapping: A mapping from CURIE prefixes to new CURIE prefixes. Old CURIE prefixes become synonyms in the records (i.e., they aren't forgotten). :returns: An upgraded converter """ ordering = _order_curie_remapping(converter, remapping) intersection = set(remapping).intersection(remapping.values()) records = {r.prefix: r for r in converter.records} modified_records = [] for old, new_prefix in ordering: _old_record = converter.get_record(old) _old = _old_record.prefix if _old_record else None if _old is None: logger.debug( "Remapping %s->%s can not be applied because %s does not appear in the converter. Skipping.", old, new_prefix, old, ) continue record = records.pop(_old) new_record = converter.get_record(new_prefix) if new_record is not None and record != new_record: logger.debug( "Remapping %s->%s would create a clash because of the existing record %r. Skipping.", old, new_prefix, new_record, ) elif old in intersection: record.prefix_synonyms = sorted( set(record.prefix_synonyms).difference({old, new_prefix}) ) record.prefix = new_prefix else: record.prefix_synonyms = sorted( set(record.prefix_synonyms).union({record.prefix}).difference({new_prefix}) ) record.prefix = new_prefix modified_records.append(record) return Converter([*records.values(), *modified_records]) def remap_uri_prefixes(converter: Converter, remapping: Mapping[str, str]) -> Converter: """Apply URI prefix remappings. :param converter: A converter :param remapping: A mapping from URI prefixes to new URI prefixes. Old URI prefixes become synonyms in the records (i.e., they aren't forgotten) :returns: An upgraded converter :raises TransitiveError: If there are any strings that appear in both the key and values of the remapping """ intersection = set(remapping).intersection(remapping.values()) if intersection: raise TransitiveError(intersection) records = [] for record in converter.records: new_uri_prefix = _get_uri_preferred_or_synonym(record, remapping) if new_uri_prefix is None: pass # nothing to upgrade elif ( new_uri_prefix in converter.reverse_prefix_map and new_uri_prefix not in record.uri_prefix_synonyms ): pass # would create a clash, don't do anything else: record.uri_prefix_synonyms = sorted( set(record.uri_prefix_synonyms) .union({record.uri_prefix}) .difference({new_uri_prefix}) ) record.uri_prefix = new_uri_prefix records.append(record) return Converter(records) def rewire(converter: Converter, rewiring: Mapping[str, str]) -> Converter: """Apply URI prefix upgrades. :param converter: A converter :param rewiring: A mapping from CURIE prefixes to new URI prefixes. If CURIE prefixes are not already in the converter, new records are created. If new URI prefixes clash with any existing ones, they are not added. :returns: An upgraded converter """ records = [] for record in converter.records: new_uri_prefix = _get_curie_preferred_or_synonym(record, rewiring) if new_uri_prefix is None: pass # nothing to upgrade elif new_uri_prefix == record.uri_prefix: pass # it's already the preferred prefix, nothing to do elif ( new_uri_prefix in converter.reverse_prefix_map and new_uri_prefix not in record.uri_prefix_synonyms ): logger.debug( "Rewiring %r to %s would create a clash because of the existing record %s. Skipping.", record, new_uri_prefix, converter.reverse_prefix_map[new_uri_prefix], ) else: record.uri_prefix_synonyms = sorted( set(record.uri_prefix_synonyms) .union({record.uri_prefix}) .difference({new_uri_prefix}) ) record.uri_prefix = new_uri_prefix records.append(record) # potential future functionality: add missing records # for prefix, new_uri_prefix in rewiring.items(): # if prefix not in converter.synonym_to_prefix: # records.append(Record(prefix=prefix, uri_prefix=new_uri_prefix)) return Converter(records) def _get_curie_preferred_or_synonym(record: Record, upgrades: Mapping[str, str]) -> str | None: if record.prefix in upgrades: return upgrades[record.prefix] for s in record.prefix_synonyms: if s in upgrades: return upgrades[s] return None def _get_uri_preferred_or_synonym(record: Record, upgrades: Mapping[str, str]) -> str | None: if record.uri_prefix in upgrades: return upgrades[record.uri_prefix] for s in record.uri_prefix_synonyms: if s in upgrades: return upgrades[s] return None class DuplicateValues(ValueError): """Raised when multiple values in the remapping correspond to the same preferred CURIE prefix.""" class DuplicateKeys(ValueError): """Raised when multiple keys in the remapping correspond to the same preferred CURIE prefix.""" class InconsistentMapping(ValueError): """Raised when inconsistent prefixes are used in the keys and values of the remapping.""" class CycleDetected(ValueError): """Raised when the remapping induces a cycle.""" def _order_curie_remapping( converter: Converter, curie_remapping: Mapping[str, str] ) -> list[tuple[str, str]]: # Check that no keys of the remapping actually correspond to the same primary prefix key_counter = defaultdict(list) for key in curie_remapping: key_counter[converter.standardize_prefix(key)].append(key) duplicate_keys = { k: Counter(values) for k, values in key_counter.items() if len(values) > 1 and k is not None } if duplicate_keys: raise DuplicateKeys(f"Duplicate keys in remapping: {duplicate_keys}") # Check that it's not the case that multiple prefixes are mapping # to the same new prefix. value_counter = defaultdict(list) for value in curie_remapping.values(): value_counter[converter.standardize_prefix(value)].append(value) duplicate_values = { k: Counter(values) for k, values in value_counter.items() if len(values) > 1 and k is not None } if duplicate_values: raise DuplicateValues(f"Duplicate values in remapping: {duplicate_values}") # Check that the correspondence is same for both correspondence_counter = defaultdict(set) for key, value in curie_remapping.items(): norm_key = converter.standardize_prefix(key) norm_val = converter.standardize_prefix(value) correspondence_counter[norm_key].add(key) # don't penalize synonym remappings if norm_key != norm_val: correspondence_counter[norm_val].add(value) duplicate_correspondence = { k: Counter(values) for k, values in correspondence_counter.items() if len(values) > 1 and k is not None } if duplicate_correspondence: raise InconsistentMapping( f"Inconsistent usage of prefixes in keys and values: {duplicate_correspondence}" ) # Given the two tests before, we don't have to worry about any clashes, and # we can work directly on primary prefixes if not set(curie_remapping).intersection(curie_remapping.values()): # No logic necessary, so just sort based on key to be consistent return sorted(curie_remapping.items()) # assume that there are no duplicates in the values rv = [] d = dict(curie_remapping) while d: no_outgoing = set(d.values()).difference(d) if not no_outgoing: raise CycleDetected("cycle detected in remapping") edges = sorted((k, v) for k, v in d.items() if v in no_outgoing) rv.extend(edges) d = {k: v for k, v in d.items() if v not in no_outgoing} return rv biopragmatics-curies-aa8bd37/src/curies/resolver_service.py000066400000000000000000000230771525104130300243400ustar00rootroot00000000000000"""A simple web service for resolving CURIEs.""" from __future__ import annotations from collections.abc import Mapping from typing import TYPE_CHECKING, Any from .api import Converter if TYPE_CHECKING: import fastapi import flask from werkzeug.wrappers import Response __all__ = [ "get_fastapi_app", "get_fastapi_router", "get_flask_app", "get_flask_blueprint", ] #: The code for `Unprocessable Entity `_ FAILURE_CODE = 422 def get_flask_blueprint(converter: Converter, **kwargs: Any) -> flask.Blueprint: """Get a blueprint for :class:`flask.Flask`. :param converter: A converter :param kwargs: Keyword arguments passed through to :class:`flask.Blueprint` :returns: A blueprint The following is an end-to-end example of using this function to create a small web resolver application. .. code-block:: python # flask_example.py from flask import Flask from curies import Converter, get_flask_blueprint, get_obo_converter # Create a converter converter: Converter = get_obo_converter() # Create a blueprint from the converter blueprint = get_flask_blueprint(converter) # Create the Flask app and mount the router app = Flask(__name__) app.register_blueprint(blueprint) if __name__ == "__main__": app.run() In the command line, either run your Python file directly, or via with :mod:`gunicorn`: .. code-block:: console $ pip install gunicorn $ gunicorn --bind 0.0.0.0:8764 flask_example:app Test a request in the Python REPL. .. code-block:: python import requests url = requests.get("http://localhost:8764/GO:0032571").url assert url == "http://amigo.geneontology.org/amigo/term/GO:0032571" """ from flask import Blueprint, abort, redirect blueprint = Blueprint("metaresolver", __name__, **kwargs) @blueprint.route(f"/{converter.delimiter}") def resolve(prefix: str, identifier: str) -> Response: """Resolve a CURIE.""" location = converter.expand_pair(prefix, identifier) if location is None: prefixes = "".join([f"\n- {p}" for p in sorted(converter.get_prefixes())]) return abort(FAILURE_CODE, f"Invalid prefix: {prefix}. Use one of:{prefixes}") return redirect(location) return blueprint def get_flask_app( converter: Converter, blueprint_kwargs: Mapping[str, Any] | None = None, flask_kwargs: Mapping[str, Any] | None = None, register_kwargs: Mapping[str, Any] | None = None, ) -> flask.Flask: """Get a Flask app. :param converter: A converter :param blueprint_kwargs: Keyword arguments passed through to :class:`flask.Blueprint` :param flask_kwargs: Keyword arguments passed through to :class:`flask.Flask` :param register_kwargs: Keyword arguments passed through to :meth:`flask.Flask.register_blueprint` :returns: A Flask app .. seealso:: This function wraps :func:`get_flask_blueprint`. If you already have your own Flask app, :func:`get_flask_blueprint` can be used to create a blueprint that you can mount using :meth:`flask.Flask.register_blueprint`. The following is an end-to-end example of using this function to create a small web resolver application. .. code-block:: python # flask_example.py from flask import Flask from curies import Converter, get_flask_app, get_obo_converter # Create a converter converter: Converter = get_obo_converter() # Create the Flask app app: Flask = get_flask_app(converter) if __name__ == "__main__": app.run() In the command line, either run your Python file directly to use Flask/Werkzeug's built-in development server, or run it with :mod:`gunicorn`: .. code-block:: console $ pip install gunicorn $ gunicorn --bind 0.0.0.0:8764 flask_example:app Alternatively, this package contains a CLI in :mod:`curies.cli` that can be used to quickly deploy a resolver based on one of the preset prefix maps, a local prefix map, or a remote one via URL. The one-line equivalent of the example file is: .. code-block:: console $ python -m curies --port 8764 --framework flask --server gunicorn obo Finally, test a request in the Python REPL. .. code-block:: python import requests url = requests.get("http://localhost:8764/GO:0032571").url assert url == "http://amigo.geneontology.org/amigo/term/GO:0032571" """ from flask import Flask blueprint = get_flask_blueprint(converter, **(blueprint_kwargs or {})) app = Flask(__name__, **(flask_kwargs or {})) app.register_blueprint(blueprint, **(register_kwargs or {})) return app def get_fastapi_router(converter: Converter, **kwargs: Any) -> fastapi.APIRouter: """Get a router for :class:`fastapi.FastAPI`. :param converter: A converter :param kwargs: Keyword arguments passed through to :class:`fastapi.APIRouter` :returns: A router The following is an end-to-end example of using this function to create a small web resolver application. Create a python file with your :class:`fastapi.FastAPI` instance: .. code-block:: python # fastapi_example.py from fastapi import FastAPI from curies import Converter, get_fastapi_router # Create a converter converter = Converter.get_obo_converter() # Create a router from the converter router = get_fastapi_router(converter) # Create the FastAPI and mount the router app = FastAPI() app.include_router(router) In the command line,, run your Python file with :mod:`uvicorn`: .. code-block:: console $ pip install uvicorn $ uvicorn fastapi_example:app --port 8764 --host 0.0.0.0 Test a request in the Python REPL. .. code-block:: python import requests url = requests.get("http://localhost:8764/GO:0032571").url assert url == "http://amigo.geneontology.org/amigo/term/GO:0032571" """ from fastapi import APIRouter, HTTPException, Path from fastapi.responses import RedirectResponse api_router = APIRouter(**kwargs) @api_router.get(f"/{{prefix}}{converter.delimiter}{{identifier}}") def resolve( prefix: str = Path( title="Prefix", description="The Bioregistry prefix corresponding to an identifier resource.", examples=["doid"], ), identifier: str = Path( title="Local Unique Identifier", description="The local unique identifier in the identifier resource referenced by the prefix.", ), ) -> RedirectResponse: """Resolve a CURIE.""" location = converter.expand_pair(prefix, identifier) if location is None: prefixes = ", ".join(sorted(converter.get_prefixes())) raise HTTPException( status_code=FAILURE_CODE, detail=f"Invalid prefix: {prefix}. Use one of: {prefixes}", ) return RedirectResponse(location, status_code=302) return api_router def get_fastapi_app( converter: Converter, router_kwargs: Mapping[str, Any] | None = None, fastapi_kwargs: Mapping[str, Any] | None = None, include_kwargs: Mapping[str, Any] | None = None, ) -> fastapi.FastAPI: """Get a FastAPI app. :param converter: A converter :param router_kwargs: Keyword arguments passed through to :class:`fastapi.APIRouter` :param fastapi_kwargs: Keyword arguments passed through to :class:`fastapi.FastAPI` :param include_kwargs: Keyword arguments passed through to :meth:`fastapi.FastAPI.include_router` :returns: A FastAPI app .. seealso:: This function wraps :func:`get_fastapi_router`. If you already have your own FastAPI app, :func:`get_fastapi_router` can be used to create a :class:`fastapi.APIRouter` that you can mount using :meth:`fastapi.FastAPI.include_router`. The following is an end-to-end example of using this function to create a small web resolver application. Create a python file with your :class:`fastapi.FastAPI` instance: .. code-block:: python # fastapi_example.py from fastapi import FastAPI from curies import Converter, get_fastapi_app # Create a converter converter = Converter.get_obo_converter() # Create the FastAPI app: FastAPI = get_fastapi_app(converter) In the command line,, run your Python file with :mod:`uvicorn`: .. code-block:: console $ pip install uvicorn $ uvicorn fastapi_example:app --port 8764 --host 0.0.0.0 Alternatively, this package contains a CLI in :mod:`curies.cli` that can be used to quickly deploy a resolver based on one of the preset prefix maps, a local prefix map, or a remote one via URL. The one-line equivalent of the example file is: .. code-block:: console $ python -m curies --framework fastapi --server uvicorn obo Finally, test a request in the Python REPL. .. code-block:: python import requests url = requests.get("http://localhost:8764/GO:0032571").url assert url == "http://amigo.geneontology.org/amigo/term/GO:0032571" """ from fastapi import FastAPI router = get_fastapi_router(converter, **(router_kwargs or {})) app = FastAPI(**(fastapi_kwargs or {})) app.include_router(router, **(include_kwargs or {})) return app biopragmatics-curies-aa8bd37/src/curies/sources.py000066400000000000000000000117461525104130300224420ustar00rootroot00000000000000"""External sources of contexts.""" from __future__ import annotations from typing import Any from .api import Converter __all__ = [ "get_bioregistry_converter", "get_go_converter", "get_monarch_converter", "get_obo_converter", "get_prefixcommons_converter", ] BIOREGISTRY_CONTEXTS = ( "https://raw.githubusercontent.com/biopragmatics/bioregistry/main/exports/contexts" ) def get_obo_converter() -> Converter: """Get the latest OBO Foundry context. :returns: A converter object representing the OBO Foundry's JSON-LD context, which contains a simple mapping from OBO Foundry preferred prefixes for ontologies that contain case stylization (e.g., ``GO``, not ``go``; ``VariO``, not ``vario``). It does not include synonyms nor any non-ontology prefixes - e.g., it does not include semantic web prefixes like ``rdfs``, it does not include other useful biomedical prefixes like ``hgnc``. If you want a more comprehensive prefix map, consider using the Bioregistry via :func:`get_bioregistry_converter` or by chaining the OBO converter in front of the Bioregistry depending on your personal/project preferences using :func:`curies.chain`. Provenance: - This JSON-LD context is generated programmatically by https://github.com/OBOFoundry/OBOFoundry.github.io/blob/master/util/processor.py. - The file is accessed via from http://purl.obolibrary.org/meta/obo_context.jsonld, which is configured through the OBO Foundry's PURL server with https://github.com/OBOFoundry/purl.obolibrary.org/blob/master/www/.htaccess and ultimately points to https://raw.githubusercontent.com/OBOFoundry/OBOFoundry.github.io/master/registry/obo_context.jsonl """ # See configuration on # to see where this PURL points url = "http://purl.obolibrary.org/meta/obo_context.jsonld" return Converter.from_jsonld(url) def get_prefixcommons_converter(name: str = "monarch_context") -> Converter: """Get a Prefix Commons-maintained context. :param name: The name of the JSON-LD file (e.g., defaults to ``monarch_context``). See the full list at https://github.com/prefixcommons/prefixcommons-py/tree/master/prefixcommons/registry. :returns: A converter """ url = ( "https://raw.githubusercontent.com/prefixcommons/prefixcommons-py/master/" f"prefixcommons/registry/{name}.jsonld" ) return Converter.from_jsonld(url) def get_monarch_converter() -> Converter: """Get the Prefix Commons-maintained Monarch context.""" return get_prefixcommons_converter("monarch_context") def get_go_converter() -> Converter: """Get the Prefix Commons-maintained GO context.""" return get_prefixcommons_converter("go_context") def get_bioregistry_converter(web: bool = False, **kwargs: Any) -> Converter: """Get the latest extended prefix map from the Bioregistry [hoyt2022]_. :param web: If false, tries to import :mod:`bioregistry` and use :func:`bioregistry.get_converter` to get the converter. Otherwise, falls back to using the GitHub-hosted EPM export. :param kwargs: Keyword arguments to pass to :meth`:curies.Converter.from_extended_prefix_map` when using web-based loading. :returns: A converter representing the Bioregistry, which includes a comprehensive collection of prefixes, prefix synonyms, and URI prefix synonyms. Short summary of the Bioregistry: 1. It deduplicates and harmonizes dozens of different resources that curate partially overlapping and conflicting prefix maps 2. It contains detailed CURIE prefix synonyms to support standardization 3. It enforces the generation of a self-consistent extended prefix map The Bioregistry's primary prefixes are all standardized to be lowercase, have minimal punctuation, and be the most idiomatic possible. When this conflicts with your personal preferences/community preferences, you can chain another converter in front of the Bioregistry converter using :func:`curies.chain`. However, the Bioregistry itself presents a more sustainable way of documenting these deviations in a community-oriented way using its "context" configurations. See https://bioregistry.io/context/ for more information. One excellent example of a community context is for the OBO community (see https://bioregistry.io/context/obo), which prioritizes OBO capitalized prefixes and makes a few minor changes for backwards compatibility (e.g., renaming Orphanet). .. [hoyt2022] `Unifying the identification of biomedical entities with the Bioregistry `_ """ if not web: try: import bioregistry except ImportError: # pragma: no cover pass else: return bioregistry.manager.get_converter() url = f"{BIOREGISTRY_CONTEXTS}/bioregistry.epm.json" return Converter.from_extended_prefix_map(url, **kwargs) biopragmatics-curies-aa8bd37/src/curies/triples/000077500000000000000000000000001525104130300220565ustar00rootroot00000000000000biopragmatics-curies-aa8bd37/src/curies/triples/__init__.py000066400000000000000000000134661525104130300242010ustar00rootroot00000000000000"""Similarly to how the :mod:`curies` package enables the semantic representation of references (i.e., as CURIEs) with the :class:`curies.Reference` class, it enables the representation of semantic triples (i.e., as subject-predicate-object triples of CURIEs) with the :class:`curies.Triple` class. ###################### Constructing Triples ###################### Triples can be constructed either from strings representing CURIEs or pre-parsed :class:`Reference` objects representing CURIEs. .. code-block:: python from curies import Triple, Reference # construction with string representations of CURIEs triple = Triple( subject="mesh:C000089", predicate="skos:exactMatch", object="CHEBI:28646", ) # construction with object representations of CURIEs triple = Triple( subject=Reference(prefix="mesh", identifier="C000089"), predicate=Reference(prefix="skos", identifier="exactMatch"), object=Reference(prefix="CHEBI", identifier="28646"), ) Any reference objects can be used, including ones with names: .. code-block:: python from curies import NamableReference triple = Triple( subject=NamedReference(prefix="mesh", identifier="C000089", name="ammeline"), predicate=NamableReference(prefix="skos", identifier="exactMatch"), object=NamedReference(prefix="CHEBI", identifier="28646", name="ammeline"), ) The :class:`Triple` interface does not enforce any CURIE validation. The :meth:`Triple.from_uris` constructor implicitly performs validation against a converter while parsing. .. code-block:: python from curies import Triple, Reference, Converter converter = curies.load_prefix_map( { "mesh": "http://id.nlm.nih.gov/mesh/", "skos": "http://www.w3.org/2004/02/skos/core#", "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", } ) triple = Triple.from_uris( subject="http://id.nlm.nih.gov/mesh/C000089", predicate="http://www.w3.org/2004/02/skos/core#exactMatch", object="http://purl.obolibrary.org/obo/CHEBI_28646", converter=converter, ) ########################### Identification of Triples ########################### The ``rdf`` namespace supports the explicit reification of triples. This means that an explicit identifier (typically, a blank node) can be used to refer to a triple itself, and the ``rdf:subject``, ``rdf:predicate`` and ``rdf:object`` predicates can be used to connect the identifier representing the triple to its respective subject, predicate, and object components. RDF enables explicit reification of triples with the following: .. code-block:: PREFIX rdf: PREFIX mesh: PREFIX skos: PREFIX CHEBI: mesh:C000089 skos:exactMatch CHEBI:28646 . [] rdf:type rdf:Statement ; rdf:subject mesh:C000089 ; rdf:predicate skos:exactMatch ; rdf:object CHEBI:28646 . It would be nice to have an implementation-agnostic way of assigning an identifier to the triple. This example imagines a namespace with the prefix ``triple`` that can host identifiers for triples: .. code-block:: PREFIX rdf: PREFIX mesh: PREFIX skos: PREFIX CHEBI: PREFIX triple: mesh:C000089 skos:exactMatch CHEBI:28646 . triple:36a1f9244ea7641a90987c82f33c25c0c13712ee8f48207b2a0825f8a4e4e26a rdf:type rdf:Statement ; rdf:subject mesh:C000089 ; rdf:predicate skos:exactMatch ; rdf:object CHEBI:28646 . :meth:`curies.Converter.hash_triple` implements a deterministic, one-way hash of a triple based on the algorithm in https://ts4nfdi.github.io/mapping-sameness-identifier: .. code-block:: python import curies from curies import Triple, Converter converter = curies.load_prefix_map( { "mesh": "http://id.nlm.nih.gov/mesh/", "skos": "http://www.w3.org/2004/02/skos/core#", "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", } ) triple = Triple( subject="mesh:C000089", predicate="skos:exactMatch", object="CHEBI:28646", ) triple_id = converter.hash_triple(triple) assert triple_id == "36a1f9244ea7641a90987c82f33c25c0c13712ee8f48207b2a0825f8a4e4e26a" """ from __future__ import annotations from .filters import ( exclude_object_prefixes, exclude_prefixes_both, exclude_references_both, exclude_same_prefixes, exclude_subject_prefixes, exclude_triples, keep_object_prefixes, keep_predicates, keep_prefixes_both, keep_prefixes_either, keep_references_both, keep_references_either, keep_subject_prefixes, keep_triples_by_hash, ) from .hash_utils import encode_curie_triple, encode_uri_triple, hash_triple from .io import read_triples, write_triples from .model import StrTriple, Triple, TriplePredicate, TripleType from .ops import exclude_prefix_stratified_many_to_many __all__ = [ "StrTriple", "Triple", "TriplePredicate", "TripleType", "encode_curie_triple", "encode_uri_triple", "exclude_object_prefixes", "exclude_prefix_stratified_many_to_many", "exclude_prefixes_both", "exclude_references_both", "exclude_same_prefixes", "exclude_subject_prefixes", "exclude_triples", "hash_triple", "keep_object_prefixes", "keep_predicates", "keep_prefixes_both", "keep_prefixes_either", "keep_references_both", "keep_references_either", "keep_subject_prefixes", "keep_triples_by_hash", "read_triples", "write_triples", ] biopragmatics-curies-aa8bd37/src/curies/triples/filters.py000066400000000000000000000527171525104130300241140ustar00rootroot00000000000000"""Filter functions for triples.""" from __future__ import annotations import logging from collections.abc import Collection, Iterable from .model import Triple, TriplePredicate, TripleType from ..api import Converter, Reference __all__ = [ "exclude_object_prefixes", "exclude_prefixes_both", "exclude_references_both", "exclude_same_prefixes", "exclude_subject_prefixes", "exclude_triples", "keep_object_prefixes", "keep_predicates", "keep_prefixes_both", "keep_prefixes_either", "keep_references_both", "keep_references_either", "keep_subject_prefixes", "keep_triples_by_hash", ] logger = logging.getLogger(__name__) def _filter( func: TriplePredicate[TripleType], triples: Iterable[TripleType], progress: bool = False ) -> Iterable[TripleType]: if progress: # pragma: no cover try: from tqdm import tqdm except ImportError: logger.warning("tqdm is not installed, can't use progress bar for %s", func) else: triples = tqdm(triples, unit="triples", unit_scale=True) return filter(func, triples) def keep_prefixes_both( triples: Iterable[TripleType], prefixes: Iterable[str], *, progress: bool = False ) -> Iterable[TripleType]: """Keep triples whose subjects' and objects' prefixes are in the given prefixes. :param triples: An iterable of triples :param prefixes: A set of prefixes to use for filtering the triples :param progress: Should a progress bar be shown? :returns: A sub-iterable of triples whose subjects' and objects' prefixes are in the given prefixes >>> from curies import Triple >>> from curies.vocabulary import exact_match >>> c1, c2, c3 = "DOID:0050577", "mesh:C562966", "umls:C4551571" >>> m1 = Triple.from_curies(c1, exact_match.curie, c2) >>> m2 = Triple.from_curies(c2, exact_match.curie, c3) >>> m3 = Triple.from_curies(c1, exact_match.curie, c3) >>> assert list(keep_prefixes_both([m1, m2, m3], {"DOID", "mesh"})) == [m1] """ return _filter(_keep_prefixes_both_filter(prefixes), triples, progress=progress) def _keep_prefixes_both_filter(prefixes: Iterable[str]) -> TriplePredicate[TripleType]: prefixes = set(prefixes) if len(prefixes) < 2: raise ValueError def _func(triple: TripleType) -> bool: return triple.subject.prefix in prefixes and triple.object.prefix in prefixes return _func def keep_prefixes_either( triples: Iterable[TripleType], prefixes: str | Iterable[str], *, progress: bool = False ) -> Iterable[TripleType]: """Keep triples whose subjects' and objects' prefixes are in the given prefixes. :param triples: An iterable of triples :param prefixes: A set of prefixes to use for filtering the triples :param progress: Should a progress bar be shown? :returns: A sub-iterable of triples whose subjects' and objects' prefixes are in the given prefixes >>> from curies import Triple >>> from curies.vocabulary import exact_match >>> c1, c2, c3 = "DOID:0050577", "mesh:C562966", "umls:C4551571" >>> m1 = Triple.from_curies(c1, exact_match.curie, c2) >>> m2 = Triple.from_curies(c2, exact_match.curie, c3) >>> m3 = Triple.from_curies(c1, exact_match.curie, c3) >>> assert list(keep_prefixes_either([m1, m2, m3], {"DOID", "mesh"})) == [m1] """ return _filter(_keep_prefixes_either_filter(prefixes), triples, progress=progress) def _keep_prefixes_either_filter(prefixes: Iterable[str]) -> TriplePredicate[TripleType]: if isinstance(prefixes, str): def _func(triple: TripleType) -> bool: return triple.subject.prefix == prefixes or triple.object.prefix == prefixes else: prefixes = set(prefixes) def _func(triple: TripleType) -> bool: return triple.subject.prefix in prefixes or triple.object.prefix in prefixes return _func def keep_subject_prefixes( triples: Iterable[TripleType], prefixes: str | Iterable[str], *, progress: bool = False ) -> Iterable[TripleType]: """Keep triples whose subjects' prefixes are in the given prefixes. :param triples: An iterable of triples :param prefixes: A set of prefixes to use for filtering the triples :param progress: Should a progress bar be shown? :returns: A sub-iterable of triples whose subjects' prefixes are in the given prefixes >>> from curies import Triple >>> from curies.vocabulary import exact_match >>> c1, c2, c3 = "DOID:0050577", "mesh:C562966", "umls:C4551571" >>> m1 = Triple.from_curies(c1, exact_match.curie, c2) >>> m2 = Triple.from_curies(c2, exact_match.curie, c3) >>> m3 = Triple.from_curies(c1, exact_match.curie, c3) >>> assert list(keep_subject_prefixes([m1, m2, m3], {"DOID"})) == [m1, m3] """ return _filter(_keep_subject_prefixes_filter(prefixes), triples, progress=progress) def _keep_subject_prefixes_filter(prefixes: str | Iterable[str]) -> TriplePredicate[TripleType]: if isinstance(prefixes, str): def _func(triple: TripleType) -> bool: return triple.subject.prefix == prefixes else: prefixes = set(prefixes) def _func(triple: TripleType) -> bool: return triple.subject.prefix in prefixes return _func def keep_object_prefixes( triples: Iterable[TripleType], prefixes: str | Iterable[str], *, progress: bool = False ) -> Iterable[TripleType]: """Keep triples whose objects' prefixes are in the given prefixes. :param triples: An iterable of triples :param prefixes: A set of prefixes to use for filtering the triples :param progress: Should a progress bar be shown? :returns: A sub-iterable of triples whose objects' prefixes are in the given prefixes >>> from curies import Triple >>> from curies.vocabulary import exact_match >>> c1, c2, c3 = "DOID:0050577", "mesh:C562966", "umls:C4551571" >>> m1 = Triple.from_curies(c1, exact_match.curie, c2) >>> m2 = Triple.from_curies(c2, exact_match.curie, c3) >>> m3 = Triple.from_curies(c1, exact_match.curie, c3) >>> assert list(keep_object_prefixes([m1, m2, m3], {"umls"})) == [m2, m3] """ return _filter(_keep_object_prefixes_filter(prefixes), triples, progress=progress) def _keep_object_prefixes_filter(prefixes: str | Iterable[str]) -> TriplePredicate[TripleType]: if isinstance(prefixes, str): def _func(triple: TripleType) -> bool: return triple.object.prefix == prefixes else: prefixes = set(prefixes) def _func(triple: TripleType) -> bool: return triple.object.prefix in prefixes return _func def exclude_prefixes_both( triples: Iterable[TripleType], prefixes: str | Iterable[str], *, progress: bool = False ) -> Iterable[TripleType]: """Exclude triples whose subjects' and objects' prefixes are in the given prefixes. :param triples: An iterable of triples :param prefixes: A set of prefixes to use for filtering the triples :param progress: Should a progress bar be shown? :returns: A sub-iterable of triples whose subjects' and objects' prefixes are not in the given prefixes >>> from curies import Triple >>> from curies.vocabulary import exact_match >>> c1, c2, c3 = "DOID:0050577", "mesh:C562966", "umls:C4551571" >>> m1 = Triple.from_curies(c1, exact_match.curie, c2) >>> m2 = Triple.from_curies(c2, exact_match.curie, c3) >>> m3 = Triple.from_curies(c1, exact_match.curie, c3) >>> assert list(exclude_prefixes_both([m1, m2, m3], {"umls"})) == [m1] >>> assert list(exclude_prefixes_both([m1, m2, m3], {"DOID"})) == [m2] >>> assert list(exclude_prefixes_both([m1, m2, m3], {"mesh"})) == [m3] """ return _filter(_exclude_prefixes_filter(prefixes), triples, progress=progress) def _exclude_prefixes_filter(prefixes: str | Iterable[str]) -> TriplePredicate[TripleType]: if isinstance(prefixes, str): def _func(triple: TripleType) -> bool: return triple.subject.prefix != prefixes and triple.object.prefix != prefixes else: prefixes = set(prefixes) def _func(triple: TripleType) -> bool: return triple.subject.prefix not in prefixes and triple.object.prefix not in prefixes return _func def exclude_subject_prefixes( triples: Iterable[TripleType], prefixes: str | Iterable[str], *, progress: bool = False ) -> Iterable[TripleType]: """Exclude triples whose subjects' prefixes are in the given prefixes. :param triples: An iterable of triples :param prefixes: A set of prefixes to use for filtering the triples :param progress: Should a progress bar be shown? :returns: A sub-iterable of triples whose subjects' prefixes are not in the given prefixes >>> from curies import Triple >>> from curies.vocabulary import exact_match >>> c1, c2, c3 = "DOID:0050577", "mesh:C562966", "umls:C4551571" >>> m1 = Triple.from_curies(c1, exact_match.curie, c2) >>> m2 = Triple.from_curies(c2, exact_match.curie, c3) >>> m3 = Triple.from_curies(c1, exact_match.curie, c3) >>> assert list(exclude_subject_prefixes([m1, m2, m3], {"DOID"})) == [m2] >>> assert list(exclude_subject_prefixes([m1, m2, m3], {"umls"})) == [m1, m2, m3] >>> assert list(exclude_subject_prefixes([m1, m2, m3], {"mesh"})) == [m1, m3] """ return _filter(_exclude_subject_prefixes_filter(prefixes), triples, progress=progress) def _exclude_subject_prefixes_filter(prefixes: str | Iterable[str]) -> TriplePredicate[TripleType]: if isinstance(prefixes, str): def _func(triple: TripleType) -> bool: return triple.subject.prefix != prefixes else: prefixes = set(prefixes) def _func(triple: TripleType) -> bool: return triple.subject.prefix not in prefixes return _func def exclude_object_prefixes( triples: Iterable[TripleType], prefixes: str | Iterable[str], *, progress: bool = False ) -> Iterable[TripleType]: """Exclude triples whose objects' prefixes are in the given prefixes. :param triples: An iterable of triples :param prefixes: A set of prefixes to use for filtering the triples :param progress: Should a progress bar be shown? :returns: A sub-iterable of triples whose objects' prefixes are not in the given prefixes >>> from curies import Triple >>> from curies.vocabulary import exact_match >>> c1, c2, c3 = "DOID:0050577", "mesh:C562966", "umls:C4551571" >>> m1 = Triple.from_curies(c1, exact_match.curie, c2) >>> m2 = Triple.from_curies(c2, exact_match.curie, c3) >>> m3 = Triple.from_curies(c1, exact_match.curie, c3) >>> assert list(exclude_object_prefixes([m1, m2, m3], {"umls"})) == [m1] >>> assert list(exclude_object_prefixes([m1, m2, m3], {"mesh"})) == [m2, m3] >>> assert list(exclude_object_prefixes([m1, m2, m3], {"DOID"})) == [m1, m2, m3] """ return _filter(_exclude_object_prefixes_filter(prefixes), triples, progress=progress) def _exclude_object_prefixes_filter(prefixes: str | Iterable[str]) -> TriplePredicate[TripleType]: if isinstance(prefixes, str): def _func(triple: TripleType) -> bool: return triple.object.prefix != prefixes else: prefixes = set(prefixes) def _func(triple: TripleType) -> bool: return triple.object.prefix not in prefixes return _func def exclude_same_prefixes( triples: Iterable[TripleType], *, progress: bool = False ) -> Iterable[TripleType]: """Exclude triples whose subject and object prefixes are the same. :param triples: An iterable of triples :param progress: Should a progress bar be shown? :returns: A sub-iterable of triples whose subject and object prefixes are not the same. >>> from curies import Triple >>> from curies.vocabulary import exact_match, subclass_of >>> c1, c2, c3 = "DOID:0050577", "mesh:C562966", "DOID:225" >>> m1 = Triple.from_curies(c1, exact_match.curie, c2) >>> m2 = Triple.from_curies(c2, exact_match.curie, c3) >>> m3 = Triple.from_curies(c1, subclass_of.curie, c3) >>> assert list(exclude_same_prefixes([m1, m2, m3])) == [m1, m2] """ return _filter(_same_prefix_filter, triples, progress=progress) def _same_prefix_filter(triple: TripleType) -> bool: return triple.subject.prefix != triple.object.prefix def keep_triples_by_hash( triples: Iterable[TripleType], converter: Converter, triple_hashes: str | Iterable[str], *, progress: bool = False, ) -> Iterable[TripleType]: """Keep triples whose triple hash (under the given converter) is in the given collection. :param triples: An iterable of triples :param converter: A converter :param triple_hashes: A hash or hashs to check triples for :param progress: Should a progress bar be shown? :returns: A sub-iterable of triples whose triple hash under the given constructor appears in the given collection >>> from curies import Triple, Converter >>> from curies.vocabulary import exact_match, subclass_of >>> converter = Converter.from_prefix_map( ... { ... "DOID": "http://purl.obolibrary.org/obo/DOID_", ... "skos": "http://www.w3.org/2004/02/skos/core#", ... "mesh": "http://id.nlm.nih.gov/mesh/", ... "umls": "https://uts.nlm.nih.gov/uts/umls/concept/", ... } ... ) >>> c1, c2, c3 = "DOID:0050577", "mesh:C562966", "DOID:225" >>> m1 = Triple.from_curies(c1, exact_match.curie, c2) >>> m2 = Triple.from_curies(c2, exact_match.curie, c3) >>> m3 = Triple.from_curies(c1, subclass_of.curie, c3) >>> m1_hash = "081f943d3791dae3a85f8eb9190fee3fbdc47ba269a374e4a0a28a2b0b982625" >>> assert list(keep_triples_by_hash([m1, m2, m3], converter, m1_hash)) == [m1] """ return _filter(_triple_has_hash(converter, triple_hashes), triples, progress=progress) def _triple_has_hash( converter: Converter, triple_hashes: str | Iterable[str] ) -> TriplePredicate[TripleType]: if isinstance(triple_hashes, str): def _func(triple: TripleType) -> bool: return converter.hash_triple(triple) == triple_hashes else: triple_hashes = set(triple_hashes) def _func(triple: TripleType) -> bool: return converter.hash_triple(triple) in triple_hashes return _func def exclude_triples( triples: Iterable[TripleType], exclusion: TripleType | Collection[TripleType], *, progress: bool = False, ) -> Iterable[TripleType]: """Exclude triples in the given set. :param triples: An iterable of triples :param exclusion: A triple or collection of triples to exclude :param progress: Should a progress bar be shown? :returns: A sub-iterable of triples whose subject and object prefixes are not the same. >>> from curies import Triple >>> from curies.vocabulary import exact_match, subclass_of >>> c1, c2, c3 = "DOID:0050577", "mesh:C562966", "DOID:225" >>> m1 = Triple.from_curies(c1, exact_match.curie, c2) >>> m2 = Triple.from_curies(c2, exact_match.curie, c3) >>> m3 = Triple.from_curies(c1, subclass_of.curie, c3) >>> assert list(exclude_triples([m1, m2, m3], m3)) == [m1, m2] """ return _filter(_exclude_triples(exclusion), triples, progress=progress) def _exclude_triples( exclusion_triples: TripleType | Iterable[TripleType], ) -> TriplePredicate[TripleType]: if isinstance(exclusion_triples, Triple): exclusion_triples_ = {exclusion_triples} else: exclusion_triples_ = set(exclusion_triples) def _func(triple: TripleType) -> bool: return triple not in exclusion_triples_ return _func def keep_references_either( triples: Iterable[TripleType], references: Reference | Collection[Reference], *, progress: bool = False, ) -> Iterable[TripleType]: """Keep triples whose subject and object appear in the given references. :param triples: An iterable of triples :param references: A collection of references :param progress: Should a progress bar be shown? :returns: A sub-iterable of triples whose subject and object appear in the given references. >>> from curies import Reference, Triple >>> from curies.vocabulary import exact_match, subclass_of >>> c1, c2, c3 = "DOID:0050577", "mesh:C562966", "DOID:225" >>> r1, r2, r3 = (Reference.from_curie(c) for c in (c1, c2, c3)) >>> m1 = Triple.from_curies(c1, exact_match.curie, c2) >>> m2 = Triple.from_curies(c2, exact_match.curie, c3) >>> m3 = Triple.from_curies(c1, subclass_of.curie, c3) >>> assert list(keep_references_either([m1, m2, m3], [r2, r1])) == [m1] """ return _filter(_include_references_either(references), triples, progress=progress) def _include_references_either( references: Reference | Collection[Reference], ) -> TriplePredicate[TripleType]: if isinstance(references, Reference): def _func(triple: TripleType) -> bool: return triple.subject == references or triple.object == references else: references = set(references) def _func(triple: TripleType) -> bool: return triple.subject in references or triple.object in references return _func def keep_references_both( triples: Iterable[TripleType], references: Collection[Reference], *, progress: bool = False ) -> Iterable[TripleType]: """Keep triples whose subject and object appear in the given references. :param triples: An iterable of triples :param references: A collection of references :param progress: Should a progress bar be shown? :returns: A sub-iterable of triples whose subject and object appear in the given references. >>> from curies import Reference, Triple >>> from curies.vocabulary import exact_match, subclass_of >>> c1, c2, c3 = "DOID:0050577", "mesh:C562966", "DOID:225" >>> r1, r2, r3 = (Reference.from_curie(c) for c in (c1, c2, c3)) >>> m1 = Triple.from_curies(c1, exact_match.curie, c2) >>> m2 = Triple.from_curies(c2, exact_match.curie, c3) >>> m3 = Triple.from_curies(c1, subclass_of.curie, c3) >>> assert list(keep_references_both([m1, m2, m3], [r2, r1])) == [m1] """ return _filter(_include_references_both(references), triples, progress=progress) def _include_references_both(references: Collection[Reference]) -> TriplePredicate[TripleType]: references = set(references) if len(references) < 2: raise ValueError("two or more references are required") def _func(triple: TripleType) -> bool: return triple.subject in references and triple.object in references return _func def exclude_references_both( triples: Iterable[TripleType], references: Reference | Collection[Reference], *, progress: bool = False, ) -> Iterable[TripleType]: """Exclude triples whose subject and object appear in the given references. :param triples: An iterable of triples :param references: A collection of references :param progress: Should a progress bar be shown? :returns: A sub-iterable of triples whose subject and object don't appear in the given references. >>> from curies import Reference, Triple >>> from curies.vocabulary import exact_match, subclass_of >>> c1, c2, c3 = "DOID:0050577", "mesh:C562966", "DOID:225" >>> r1, r2, r3 = (Reference.from_curie(c) for c in (c1, c2, c3)) >>> m1 = Triple.from_curies(c1, exact_match.curie, c2) >>> m2 = Triple.from_curies(c2, exact_match.curie, c3) >>> m3 = Triple.from_curies(c1, subclass_of.curie, c3) >>> assert list(exclude_references_both([m1, m2, m3], [r1])) == [m2] >>> assert list(exclude_references_both([m1, m2, m3], [r2])) == [m3] >>> assert list(exclude_references_both([m1, m2, m3], [r3])) == [m1] """ return _filter(_exclude_references(references), triples, progress=progress) def _exclude_references( references: Reference | Collection[Reference], ) -> TriplePredicate[TripleType]: if isinstance(references, Reference): references = {references} else: references = set(references) def _func(triple: TripleType) -> bool: return triple.subject not in references and triple.object not in references return _func def keep_predicates( triples: Iterable[TripleType], predicates: Reference | Collection[Reference], *, progress: bool = False, ) -> Iterable[TripleType]: """Keep triples whose predicate appear in the given references. :param triples: An iterable of triples :param predicates: A collection of references :param progress: Should a progress bar be shown? :returns: A sub-iterable of triples whose predicate appear in the given references. >>> from curies import Reference, Triple >>> from curies.vocabulary import exact_match, subclass_of >>> c1, c2, c3 = "DOID:0050577", "mesh:C562966", "DOID:225" >>> r1, r2, r3 = (Reference.from_curie(c) for c in (c1, c2, c3)) >>> m1 = Triple.from_curies(c1, exact_match.curie, c2) >>> m2 = Triple.from_curies(c2, exact_match.curie, c3) >>> m3 = Triple.from_curies(c1, subclass_of.curie, c3) >>> assert list(keep_predicates([m1, m2, m3], exact_match)) == [m1, m2] """ return _filter(_include_predicates(predicates), triples, progress=progress) def _include_predicates( predicates: Reference | Collection[Reference], ) -> TriplePredicate[TripleType]: if isinstance(predicates, Reference): def _func(triple: TripleType) -> bool: return triple.predicate == predicates else: predicates = set(predicates) def _func(triple: TripleType) -> bool: return triple.predicate in predicates return _func biopragmatics-curies-aa8bd37/src/curies/triples/hash_utils.py000066400000000000000000000074461525104130300246060ustar00rootroot00000000000000"""Triple hashing utilities.""" from __future__ import annotations import hashlib from .model import Triple from ..api import Converter __all__ = [ "encode_curie_triple", "encode_uri_triple", "hash_triple", ] def hash_triple(converter: Converter, triple: Triple, *, negate: bool = False) -> str: """Encode a triple with URL-safe base64 encoding. :param converter: A converter :param triple: A triple of CURIE objects :param negate: If true, considers the triple as "negative" and postpends a ``~`` to the hash :returns: An encoded triple of URIs .. seealso:: https://ts4nfdi.github.io/mapping-sameness-identifier/ >>> import curies >>> from curies.triples import Triple >>> converter = curies.load_prefix_map( ... { ... "mesh": "http://id.nlm.nih.gov/mesh/", ... "skos": "http://www.w3.org/2004/02/skos/core#", ... "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", ... } ... ) >>> triple = Triple(subject="mesh:C000089", predicate="skos:exactMatch", object="CHEBI:28646") >>> hash_triple(converter, triple) '36a1f9244ea7641a90987c82f33c25c0c13712ee8f48207b2a0825f8a4e4e26a' >>> hash_triple(converter, triple, negate=True) '36a1f9244ea7641a90987c82f33c25c0c13712ee8f48207b2a0825f8a4e4e26a~' """ return encode_uri_triple(triple.as_uri_triple(converter), negate=negate) def encode_curie_triple( curie_triple: tuple[str, str, str], converter: Converter, *, negate: bool = False ) -> str: """Encode a subject-predicate-object CURIE triple. :param curie_triple: A triple of CURIEs represented as strings :param converter: A converter :param negate: If true, considers the triple as "negative" and postpends a ``~`` to the hash :returns: An encoded triple of URIs .. seealso:: https://ts4nfdi.github.io/mapping-sameness-identifier/ >>> import curies >>> from curies.triples import Triple >>> converter = curies.load_prefix_map( ... { ... "mesh": "http://id.nlm.nih.gov/mesh/", ... "skos": "http://www.w3.org/2004/02/skos/core#", ... "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", ... } ... ) >>> triple = ("mesh:C000089", "skos:exactMatch", "CHEBI:28646") >>> encode_curie_triple(triple, converter) '36a1f9244ea7641a90987c82f33c25c0c13712ee8f48207b2a0825f8a4e4e26a' >>> encode_curie_triple(triple, converter, negate=True) '36a1f9244ea7641a90987c82f33c25c0c13712ee8f48207b2a0825f8a4e4e26a~' """ uri_triple = ( converter.expand(curie_triple[0], strict=True), converter.expand(curie_triple[1], strict=True), converter.expand(curie_triple[2], strict=True), ) return encode_uri_triple(uri_triple, negate=negate) def encode_uri_triple(uri_triple: tuple[str, str, str], *, negate: bool = False) -> str: """Encode a subject-predicate-object URI triple. :param uri_triple: A triple of URIs represented as strings :param negate: If true, considers the triple as "negative" and postpends a ``~`` to the hash :returns: An encoded triple of URIs .. seealso:: https://ts4nfdi.github.io/mapping-sameness-identifier/ >>> triple = ( ... "http://id.nlm.nih.gov/mesh/C000089", ... "http://www.w3.org/2004/02/skos/core#exactMatch", ... "http://purl.obolibrary.org/obo/CHEBI_28646", ... ) >>> encode_uri_triple(triple) '36a1f9244ea7641a90987c82f33c25c0c13712ee8f48207b2a0825f8a4e4e26a' >>> encode_uri_triple(triple, negate=True) '36a1f9244ea7641a90987c82f33c25c0c13712ee8f48207b2a0825f8a4e4e26a~' """ delimited_uris = " ".join(uri_triple) digest = hashlib.sha256(delimited_uris.encode("utf-8")).hexdigest() if negate: digest += "~" return digest biopragmatics-curies-aa8bd37/src/curies/triples/io.py000066400000000000000000000030151525104130300230360ustar00rootroot00000000000000"""I/O operations for triples.""" from __future__ import annotations from collections.abc import Iterable, Sequence from pathlib import Path from typing import TextIO from pystow.utils import safe_open_reader, safe_open_writer from .model import Triple from ..api import Reference __all__ = [ "HEADER", "read_triples", "write_triples", ] #: the default header for a three-column file representing triples HEADER = list(Triple.model_fields) def write_triples( triples: Iterable[Triple], path: str | Path | TextIO, *, header: Sequence[str] | None = None ) -> None: """Write triples as a three-column TSV file.""" if header is None: header = HEADER with safe_open_writer(path) as writer: writer.writerow(header) writer.writerows( (triple.subject.curie, triple.predicate.curie, triple.object.curie) for triple in triples ) def read_triples( path: str | Path | TextIO, *, reference_cls: type[Reference] | None = None ) -> list[Triple]: """Read triples from a three-column TSV file.""" if reference_cls is None: reference_cls = Reference with safe_open_reader(path) as reader: _header = next(reader) return [ Triple( subject=reference_cls.from_curie(subject_curie), predicate=reference_cls.from_curie(predicate_curie), object=reference_cls.from_curie(object_curie), ) for subject_curie, predicate_curie, object_curie in reader ] biopragmatics-curies-aa8bd37/src/curies/triples/model.py000066400000000000000000000065271525104130300235420ustar00rootroot00000000000000"""Model definitions.""" from __future__ import annotations from collections.abc import Callable from typing import NamedTuple, Self, TypeAlias, TypeVar from pydantic import BaseModel, ConfigDict from ..api import Converter, Reference __all__ = [ "StrTriple", "Triple", "TriplePredicate", "TripleType", ] class StrTriple(NamedTuple): """A triple of curies.""" subject: str predicate: str object: str class Triple(BaseModel): """A Pydantic model for a subject-predicate-object triple. Triples can be constructed either from strings representing CURIEs or pre-parsed :class:`Reference` objects representing CURIEs. .. code-block:: python from curies import Triple, Reference # construction with string representations of CURIEs triple = Triple( subject="mesh:C000089", predicate="skos:exactMatch", object="CHEBI:28646", ) # construction with object representations of CURIEs triple = Triple( subject=Reference(prefix="mesh", identifier="C000089"), predicate=Reference(prefix="skos", identifier="exactMatch"), object=Reference(prefix="CHEBI", identifier="28646"), ) .. note:: It's up to you to validate your CURIEs are semantically sound, e.g., against the :mod:`bioregistry`. """ model_config = ConfigDict(frozen=True) subject: Reference predicate: Reference object: Reference def as_str_triple(self) -> StrTriple: """Get a three-tuple of strings representing this triple.""" return StrTriple(self.subject.curie, self.predicate.curie, self.object.curie) def as_uri_triple(self, converter: Converter) -> tuple[str, str, str]: """Get a three-tuple of strings representing the expanded URIs.""" return ( converter.expand_reference(self.subject, strict=True), converter.expand_reference(self.predicate, strict=True), converter.expand_reference(self.object, strict=True), ) def __lt__(self, other: Triple) -> bool: return self.as_str_triple() < other.as_str_triple() @classmethod def from_curies( cls, subject_curie: str, predicate_curie: str, object_curie: str, *, reference_cls: type[Reference] = Reference, ) -> Self: """Construct a triple from three CURIE strings.""" return cls( subject=reference_cls.from_curie(subject_curie), predicate=reference_cls.from_curie(predicate_curie), object=reference_cls.from_curie(object_curie), ) @classmethod def from_uris( cls, subject: str, predicate: str, object: str, *, converter: Converter, reference_cls: type[Reference] = Reference, ) -> Self: """Construct a triple from three URI strings.""" return cls( subject=reference_cls.from_reference(converter.parse_uri(subject, strict=True)), predicate=reference_cls.from_reference(converter.parse_uri(predicate, strict=True)), object=reference_cls.from_reference(converter.parse_uri(object, strict=True)), ) TripleType = TypeVar("TripleType", bound=Triple) #: A predicate over a triple TriplePredicate: TypeAlias = Callable[[TripleType], bool] biopragmatics-curies-aa8bd37/src/curies/triples/ops.py000066400000000000000000000142061525104130300232340ustar00rootroot00000000000000"""Operations on triples.""" from collections import defaultdict from collections.abc import Iterable from typing import TypeAlias from .filters import exclude_triples from .model import TripleType from .. import Reference __all__ = [ "PrefixPairStratifiedIndex", "exclude_prefix_stratified_many_to_many", "exclude_triples", "get_prefix_pair_stratified_indexes", "get_prefix_stratified_many_to_many", "get_reference_indexes", ] #: A doubly-nested adjacency dictionary whose first #: keys are subject/object local unique identifier, #: second level is the opposite side local unique #: identifier, and values are the list of triples AdjacencyDict = dict[str, dict[str, list[TripleType]]] #: A pair of prefixes PrefixPair: TypeAlias = tuple[str, str] #: A multi-leveled nested dictionary that represents many-to-many mappings. #: The first key is subject/object pairs, the second key is either a subject identifier or object identifier, #: the last key is the opposite object or subject identifier, and the values are a list of mappings. #: #: This data structure can be used to index either forward or backwards mappings, #: as done inside :func:`get_many_to_many` PrefixPairStratifiedIndex: TypeAlias = dict[PrefixPair, AdjacencyDict[TripleType]] def exclude_prefix_stratified_many_to_many( triples: Iterable[TripleType], *, progress: bool = False ) -> Iterable[TripleType]: """Exclude prefix pair-stratified many-to-many relationships. .. warning:: This function does not consider the predicate, so if you only want to make this operation based on specific predicate, then pre-group your triples based on predicate. :param triples: An iterable of triples :param progress: Whether to show a progress bar :returns: An iterable of triples .. warning:: This operation fully consumes the iterator since it requires two passes """ triples = list(triples) exclusion = get_prefix_stratified_many_to_many(triples) return exclude_triples(triples, exclusion, progress=progress) def get_prefix_stratified_many_to_many(triples: Iterable[TripleType]) -> set[TripleType]: """Get many-to-many relationships.""" forward, backward = get_prefix_pair_stratified_indexes(triples) forward_sliced = get_one_to_many(forward) backwards_sliced_flipped = flip_prefix_pair_stratified_index(get_one_to_many(backward)) rv: set[TripleType] = set() for prefix_pair, forward_adjacency_dict in forward_sliced.items(): if backward_adjacency_dict := backwards_sliced_flipped.get(prefix_pair): rv.update(_compare(forward_adjacency_dict, backward_adjacency_dict)) return rv def get_prefix_pair_stratified_indexes( triples: Iterable[TripleType], ) -> tuple[PrefixPairStratifiedIndex[TripleType], PrefixPairStratifiedIndex[TripleType]]: """Get a forward and backwards subject/object index. :param triples: An iterable of triples :returns: A pair of forward and backwards indexes, where: - A forward many-to-many index is a triply-nested dictionary from subject/predicate prefix pair to subject identifier to object identifier to list of triples. - A backward many-to-many index is a triply-nested dictionary from subject/predicate prefix pair to object identifier to subject identifier to list of triples. """ # forward index f: _DD[TripleType] = defaultdict(lambda: defaultdict(lambda: defaultdict(list))) # backward index b: _DD[TripleType] = defaultdict(lambda: defaultdict(lambda: defaultdict(list))) for t in triples: f[t.subject.prefix, t.object.prefix][t.subject.identifier][t.object.identifier].append(t) b[t.object.prefix, t.subject.prefix][t.object.identifier][t.subject.identifier].append(t) return _downgrade_defaultdict(f), _downgrade_defaultdict(b) _DD = defaultdict[PrefixPair, defaultdict[str, defaultdict[str, list[TripleType]]]] def _downgrade_defaultdict(dd: _DD[TripleType]) -> PrefixPairStratifiedIndex[TripleType]: return {k1: {k2: dict(v2) for k2, v2 in v1.items()} for k1, v1 in dd.items()} def get_one_to_many( index: PrefixPairStratifiedIndex[TripleType], ) -> PrefixPairStratifiedIndex[TripleType]: """Filter an index to entities in each prefix pair with a one-to-many relationship.""" rv = {} for pair, inner in index.items(): filtered_inner = {k: v for k, v in inner.items() if len(v) > 1} if filtered_inner: rv[pair] = filtered_inner return rv def flip_prefix_pair_stratified_index( index: PrefixPairStratifiedIndex[TripleType], ) -> PrefixPairStratifiedIndex[TripleType]: """Flip a one-to-many relationship index to a many-to-one relationship index.""" rv = {} for (left, right), adjacency_dict in index.items(): flipped_adjacency_dict: defaultdict[str, dict[str, list[TripleType]]] = defaultdict(dict) for left_id, inner_dict in adjacency_dict.items(): for right_id, triples in inner_dict.items(): flipped_adjacency_dict[right_id][left_id] = triples rv[right, left] = {k: v for k, v in flipped_adjacency_dict.items() if len(v) > 1} return rv def _compare( left_adjacency_dict: AdjacencyDict[TripleType], right_adjacency_dict: AdjacencyDict[TripleType] ) -> set[TripleType]: rv = set() keys = set(left_adjacency_dict.keys()) & set(right_adjacency_dict.keys()) for key in keys: inner_keys = set(left_adjacency_dict[key]) & set(right_adjacency_dict[key]) for inner_key in inner_keys: rv.update(left_adjacency_dict[key][inner_key]) return rv #: A simple index from reference to references. This can #: either be subject to objects, or object to subjects, #: depending on the implementation. ReferenceIndex = dict[Reference, set[Reference]] def get_reference_indexes(triples: Iterable[TripleType]) -> tuple[ReferenceIndex, ReferenceIndex]: """Get simple entity indexes.""" forward = defaultdict(set) backward = defaultdict(set) for triple in triples: forward[triple.subject].add(triple.object) backward[triple.object].add(triple.subject) return dict(forward), dict(backward) biopragmatics-curies-aa8bd37/src/curies/utils.py000066400000000000000000000016051525104130300221100ustar00rootroot00000000000000"""Utilities for working with strings.""" from __future__ import annotations __all__ = [ "NoCURIEDelimiterError", "_split", ] class NoCURIEDelimiterError(ValueError): """An error thrown on a string with no delimiter.""" def __init__(self, curie: str): """Initialize the error.""" self.curie = curie def __str__(self) -> str: return f"{self.curie} does not appear to be a CURIE - missing a delimiter" def _split(curie: str, *, sep: str = ":") -> tuple[str, str]: """Split a CURIE string using string operations.""" prefix, delimiter, identifier = curie.partition(sep) if not delimiter: raise NoCURIEDelimiterError(curie) return prefix, identifier def _prefix_from_curie(curie: str, *, sep: str = ":") -> str: """Split a CURIE string using string operations and return the prefix.""" return _split(curie, sep=sep)[0] biopragmatics-curies-aa8bd37/src/curies/version.py000066400000000000000000000015721525104130300224400ustar00rootroot00000000000000"""Version information for :mod:`curies`.""" import os from subprocess import CalledProcessError, check_output __all__ = [ "VERSION", "get_version", ] VERSION = "0.15.1" def get_git_hash() -> str: """Get the :mod:`curies` git hash.""" with open(os.devnull, "w") as devnull: try: ret = check_output( ["git", "rev-parse", "HEAD"], cwd=os.path.dirname(__file__), stderr=devnull, ) except CalledProcessError: return "UNHASHED" else: return ret.strip().decode("utf-8")[:8] def get_version(with_git_hash: bool = False) -> str: """Get the :mod:`curies` version string, including a git hash.""" return f"{VERSION}-{get_git_hash()}" if with_git_hash else VERSION if __name__ == "__main__": print(get_version(with_git_hash=True)) # noqa:T201 biopragmatics-curies-aa8bd37/src/curies/vocabulary.py000066400000000000000000000410041525104130300231140ustar00rootroot00000000000000"""A module containing pre-defined references.""" from __future__ import annotations import datetime from collections.abc import Callable, Sequence from typing import Literal, TypeAlias from pydantic import AnyUrl from .api import NamedReference, Prefix, Reference def _r(p: str, i: str, n: str) -> NamedReference: return NamedReference(prefix=Prefix(p), identifier=i, name=n) # RDF Schema has_label = _r("rdfs", "label", "has label") see_also = _r("rdfs", "seeAlso", "see also") has_comment = _r("rdfs", "comment", "comment") is_a = subclass_of = _r("rdfs", "subClassOf", "subclass of") subproperty_of = _r("rdfs", "subPropertyOf", "subproperty of") rdf_type = _r("rdf", "type", "instance of") # XML Schema, see https://www.w3.org/TR/xmlschema11-2/ xsd_string = _r("xsd", "string", "string") xsd_double = _r("xsd", "double", "double-precision 64-bit floating point datatype") xsd_float = _r("xsd", "float", "float") xsd_decimal = _r("xsd", "decimal", "decimal") xsd_integer = _r("xsd", "integer", "integer") xsd_boolean = _r("xsd", "boolean", "boolean") xsd_day = _r("xsd", "gDay", "day") xsd_month = _r("xsd", "gMonth", "month") xsd_month_day = _r("xsd", "gMonthDay", "month and day") xsd_year = _r("xsd", "gYear", "year") xsd_year_month = _r("xsd", "gYearMonth", "year and month") xsd_uri = _r("xsd", "anyURI", "URI") xsd_date = _r("xsd", "date", "date") xsd_datetime = _r("xsd", "dateTime", "datetime") xsd_datetimestamp = _r("xsd", "dateTimeStamp", "datetime stamp") xsd_qname = _r("xsd", "QName", "qualified name") xsd_ncname = _r("xsd", "NCName", "non-colonized name") #: A set of common XSD type (note, not exhaustive) XSD_TYPES = { xsd_string, xsd_double, xsd_float, xsd_decimal, xsd_integer, xsd_boolean, xsd_day, xsd_month, xsd_month_day, xsd_year, xsd_year_month, xsd_uri, xsd_date, xsd_datetime, xsd_datetimestamp, xsd_qname, xsd_ncname, } def _parse_xsd_boolean_str(v: str) -> bool: if v == "true": return True elif v == "false": return False else: raise ValueError(f"value is not an XSD-conformant boolean: {v}") #: A union type for everything that can be parsed based on XSD XSDPrimitive: TypeAlias = str | float | int | datetime.datetime | datetime.date | bool | AnyUrl #: A map of XSD references to parser functions XSD_TO_PARSER: dict[Reference, Callable[[str], XSDPrimitive]] = { xsd_string: str, xsd_double: float, xsd_float: float, xsd_integer: int, xsd_uri: AnyUrl, # TODO check if pydantic is actually implementing URIs here xsd_date: datetime.date.fromisoformat, xsd_datetime: datetime.datetime.fromisoformat, xsd_boolean: _parse_xsd_boolean_str, } def parse_xsd(value: str, datatype: Reference) -> XSDPrimitive: """Parse an XSD-conformant string into a primitive type. :param value: The XSD-conformant string to parse :param datatype: A reference to an XSD term, must be inside :data:`XSD_TO_PARSER` :returns: An integer, float, date, datetime, boolean, URL, or string, depending on the datatype """ parser = XSD_TO_PARSER[datatype] return parser(value) # DC Terms has_description = _r("dcterms", "description", "description") has_license = _r("dcterms", "license", "license") has_title = _r("dcterms", "title", "title") has_contributor = _r("dcterms", "contributor", "contributor") has_creator = _r("dcterms", "creator", "creator") has_source = _r("dcterms", "source", "source") has_date = _r("dcterms", "date", "date") conforms_to = _r("dcterms", "conformsTo", "conforms to") # PAV has_author = _r("pav", "authoredBy", "authored by") # OBO in OWL obo_in_subset = _r("oboInOwl", "inSubset", "in subset") obo_has_namespace = _r("oboInOwl", "hasOBONamespace", "has OBO namespace") obo_autogenerated_by = _r("oboInOwl", "auto-generated-by", "auto-generated by") obo_creation_date = _r("oboInOwl", "creation_date", "creation date") obo_consider = _r("oboInOwl", "consider", "consider") obo_is_anonymous = _r("oboInOwl", "is_anonymous", "is anonymous") obo_builtin = _r("oboInOwl", "builtin", "built-in") obo_is_class_level = _r("oboInOwl", "is_class_level", "is class level") obo_is_cyclic = _r("oboInOwl", "is_cyclic", "is cyclic") # OWL owl_thing = _r("owl", "Thing", "thing") owl_deprecated = _r("owl", "deprecated", "is deprecated") owl_version_info = _r("owl", "versionInfo", "has version") owl_inverse_of = _r("owl", "inverseOf", "inverse of") owl_different_from = _r("owl", "differentFrom", "different from") owl_disjoint_with = _r("owl", "disjointWith", "disjoint with") owl_property_disjoint_with = _r("owl", "propertyDisjointWith", "property disjoint with") owl_complement_of = _r("owl", "complementOf", "complement of") owl_class = _r("owl", "Class", "class") owl_object_property = _r("owl", "ObjectProperty", "object property") owl_data_property = _r("owl", "DataProperty", "data property") owl_annotation_property = _r("owl", "AnnotationProperty", "annotation property") owl_named_individual = _r("owl", "NamedIndividual", "named individual") # SKOS skos_concept = _r("skos", "Concept", "concept") # RDFS rdfs_resource = _r("rdfs", "Resource", "resource") rdfs_class = _r("rdfs", "Class", "class") rdfs_literal = _r("rdfs", "Literal", "literal") rdfs_datatype = _r("rdfs", "Datatype", "datatype") rdfs_property = _r("rdfs", "Property", "property") # SSSOM composed_entity_expression = _r("sssom", "ComposedEntityExpression", "composed entity expression") # IAO has_ontology_root_term = _r("IAO", "0000700", "has ontology root term") has_term_editor = _r("IAO", "0000117", "term editor") has_obsolescence_reason = _r("IAO", "0000231", "has obsolescence reason") term_tracker_item = _r("IAO", "0000233", "term tracker item") # Document parts title_section = _r("IAO", "0000651", "title section") abstract_section = _r("IAO", "0000315", "abstract") #: A set of document parts that are subclasses of IAO:0000314 DOCUMENT_PARTS = { title_section, abstract_section, } # Synonyms ## Synonym Relations #: The parent property for having synonyms, see :data:`synonym_scopes` #: for a dictionary of all synonym types has_synonym = _r("oboInOwl", "hasSynonym", "has synonym") has_synonym_type = _r("oboInOwl", "hasSynonymType", "has synonym type") has_exact_synonym = _r("oboInOwl", "hasExactSynonym", "has exact synonym") has_narrow_synonym = _r("oboInOwl", "hasNarrowSynonym", "has narrow synonym") has_broad_synonym = _r("oboInOwl", "hasBroadSynonym", "has broad synonym") has_related_synonym = _r("oboInOwl", "hasRelatedSynonym", "has related synonym") #: A list of strings used to refer to synonym types in ``oboInOwl`` SynonymScope: TypeAlias = Literal["EXACT", "NARROW", "BROAD", "RELATED"] #: This is what happens if no specificity is given DEFAULT_SYNONYM_SCOPE: SynonymScope = "RELATED" # OBO Graph JSON uses the LUIDs from OBO in OWL, so we # keep track of these as well SynonymScopeOIO: TypeAlias = Literal[ "hasExactSynonym", "hasNarrowSynonym", "hasBroadSynonym", "hasRelatedSynonym", ] DEFAULT_SYNONYM_SCOPE_OIO: SynonymScopeOIO = "hasRelatedSynonym" #: A mapping from synonym scopes to references synonym_scopes: dict[SynonymScope, NamedReference] = { "EXACT": has_exact_synonym, "NARROW": has_narrow_synonym, "BROAD": has_broad_synonym, "RELATED": has_related_synonym, } synonym_scope_to_oio: dict[SynonymScope, SynonymScopeOIO] = { "EXACT": "hasExactSynonym", "NARROW": "hasNarrowSynonym", "BROAD": "hasBroadSynonym", "RELATED": "hasRelatedSynonym", } ## OMO Synonym Types has_ontology_hierarchical_property = _r("OMO", "0003014", "has ontology hierarchical property") #: The parent class for all synonym types, see :data:`synonym_types` #: for the set of all synonym types synonym_type = _r("oboInOwl", "SynonymType", "synonym type") abbreviation = _r("OMO", "0003000", "abbreviation") ambiguous_synonym = _r("OMO", "0003001", "ambiguous synonym") dubious_synonym = _r("OMO", "0003002", "dubious synonym") layperson_synonym = _r("OMO", "0003003", "layperson synonym") plural_form = _r("OMO", "0003004", "plural form") uk_spelling = _r("OMO", "0003005", "UK spelling synonym") misspelling = _r("OMO", "0003006", "misspelling") misnomer = _r("OMO", "0003007", "misnomer") previous_name = _r("OMO", "0003008", "previous name") legal_name = _r("OMO", "0003009", "legal name") inn = _r("OMO", "0003010", "International Nonproprietary Name") latin_term = _r("OMO", "0003011", "latin term") acronym = _r("OMO", "0003012", "acronym") #: Provisional, see https://github.com/information-artifact-ontology/ontology-metadata/pull/162/files brand_name = _r("OMO", "0003013", "brand name") #: A set of synonym types from OMO synonym_types: set[NamedReference] = { abbreviation, ambiguous_synonym, dubious_synonym, layperson_synonym, plural_form, uk_spelling, misspelling, misnomer, previous_name, legal_name, inn, latin_term, acronym, brand_name, } # LinkML #: See https://github.com/mapping-commons/sssom/pull/560 linkml_uri_or_curie = _r("linkml", "Uriorcurie", "URI or CURIE") # Semantic Mappings ## Mapping Relations #: The parent property for semantic mappings from ``skos``, see :data:`semantic_mapping_scopes` #: for a list of all usable properties match = _r("skos", "mappingRelation", "is in mapping relation with") has_dbxref = _r("oboInOwl", "hasDbXref", "has database cross-reference") same_as = _r("owl", "sameAs", "same as") equivalent_class = _r("owl", "equivalentClass", "equivalent class") equivalent_property = _r("owl", "equivalentProperty", "equivalent property") exact_match = _r("skos", "exactMatch", "exact match") narrow_match = _r("skos", "narrowMatch", "narrow match") broad_match = _r("skos", "broadMatch", "broad match") close_match = _r("skos", "closeMatch", "close match") related_match = _r("skos", "relatedMatch", "related match") editor_note = _r("IAO", "0000116", "editor note") # `alternate term` and `term replaced by` can also be considered as mapping relations alternative_term = _r("IAO", "0000118", "alternative term") term_replaced_by = _r("IAO", "0100001", "term replaced by") cross_species_exact = _r("semapv", "crossSpeciesExactMatch", "cross-species exact match") cross_species_narrow = _r("semapv", "crossSpeciesNarrowMatch", "cross-species narrow match") cross_species_broad = _r("semapv", "crossSpeciesBroadMatch", "cross-species broad match") #: A list of strings used to refer to mapping types in ``skos`` SemanticMappingScope: TypeAlias = Literal["EXACT", "NARROW", "BROAD", "CLOSE", "RELATED"] #: A mapping from mapping types to references semantic_mapping_scopes: dict[SemanticMappingScope, NamedReference] = { "EXACT": exact_match, "NARROW": narrow_match, "BROAD": broad_match, "CLOSE": close_match, "RELATED": related_match, } ## Matching Process Types #: The parent class for matching processes, see :data:`matching_processes` #: for the set of all matching processes. matching_process = _r("semapv", "Matching", "matching process") background_knowledge_based_matching_process = _r( "semapv", "BackgroundKnowledgeBasedMatching", "background knowledge-based matching process", ) composite_matching_process = _r("semapv", "CompositeMatching", "composite matching process") instance_based_matching_process = _r( "semapv", "InstanceBasedMatching", "instance-based matching process" ) lexical_matching_process = _r("semapv", "LexicalMatching", "lexical matching process") lexical_similarity_threshold_based_matching_process = _r( "semapv", "LexicalSimilarityThresholdMatching", "lexical similarity threshold-based matching process", ) logical_reasoning_matching_process = _r( "semapv", "LogicalReasoning", "logical reasoning matching process" ) manual_mapping_curation = _r("semapv", "ManualMappingCuration", "manual mapping curation") mapping_chaining = _r("semapv", "MappingChaining", "mapping chaining-based matching process") mapping_inversion = _r("semapv", "MappingInversion", "mapping inversion-based matching process") semantic_similarity = _r( "semapv", "SemanticSimilarityThresholdMatching", "semantic similarity threshold-based matching process", ) structural_matching = _r("semapv", "StructuralMatching", "structural matching process") unspecified_matching_process = _r("semapv", "UnspecifiedMatching", "unspecified matching process") #: A set of matching types from ``semapv`` matching_processes: set[NamedReference] = { background_knowledge_based_matching_process, composite_matching_process, instance_based_matching_process, lexical_matching_process, lexical_similarity_threshold_based_matching_process, logical_reasoning_matching_process, manual_mapping_curation, mapping_chaining, mapping_inversion, semantic_similarity, structural_matching, unspecified_matching_process, } #: See https://mapping-commons.github.io/sssom/spec-model/ match_typedefs: Sequence[NamedReference] = ( broad_match, close_match, exact_match, narrow_match, related_match, same_as, # for instances equivalent_class, # for classes equivalent_property, # for properties owl_disjoint_with, # for classes owl_property_disjoint_with, # for properties owl_different_from, # for instances owl_complement_of, # for classes owl_inverse_of, # for properties has_dbxref, see_also, subclass_of, subproperty_of, cross_species_broad, cross_species_exact, cross_species_narrow, ) # Extension past the SSSOM spec extended_match_typedefs: Sequence[NamedReference] = ( *match_typedefs, alternative_term, term_replaced_by, ) # Classes human = _r("NCBITaxon", "9606", "Homo sapiens") # Individuals #: the author of this package. It's useful to have this reference pre-defined #: for testing purposes charlie = _r("orcid", "0000-0003-4423-4370", "Charles Tapley Hoyt") part_of = _r("BFO", "0000050", "part of") has_part = _r("BFO", "0000051", "has part") located_in = _r("RO", "0001025", "located in") location_of = _r("RO", "0001015", "location of") enables = _r("RO", "0002327", "enables") enabled_by = _r("RO", "0002333", "enabled by") involved_in = _r("RO", "0002331", "involved in") colocalizes_with = _r("RO", "0002325", "colocalizes with") acts_upstream_of = _r("RO", "0002263", "acts upstream of") is_active_in = _r("RO", "0002432", "is active in") contributes_to = _r("RO", "0002326", "contributes to") acts_upstream_of_or_within = _r("RO", "0002264", "acts upstream of or within") acts_upstream_of_or_within_positive_effect = _r( "RO", "0004032", "acts upstream of or within, positive effect" ) acts_upstream_of_or_within_negative_effect = _r( "RO", "0004033", "acts upstream of or within, negative effect" ) acts_upstream_of_positive_effect = _r("RO", "0004034", "acts upstream of, positive effect") acts_upstream_of_negative_effect = _r("RO", "0004035", "acts upstream of, negative effect") derives_from = _r("RO", "0002202", "derives from") derives_into = _r("RO", "0001001", "derives into") contained_in = _r("RO", "0001018", "contained in") molecularly_interacts_with = _r("ro", "0002436", "molecularly interacts with") regulator_of = _r("RO", "0012004", "is small molecule regulator of") inhibitor_of = _r("RO", "0012006", "is small molecule inhibitor of") is_model_of = _r("RO", "0003301", "is model of") is_marker_for = _r("RO", "0002607", "is marker for") orthologous_to = _r("RO", "HOM0000017", "in orthology relationship with") deprotonated_form_of = _r("RO", "0018033", "is deprotonated form of") protonated_form_of = _r("RO", "0018034", "is protonated form of") has_suborganization = _r("org", "hasSubOrganization", "has suborganization") is_suborganization_of = _r("org", "subOrganizationOf", "is suborganization of") #: A mapping of inverse relationships that can be applied when inverting mappings inversions: dict[Reference, NamedReference] = { broad_match: narrow_match, narrow_match: broad_match, exact_match: exact_match, close_match: close_match, has_dbxref: has_dbxref, equivalent_class: equivalent_class, equivalent_property: equivalent_property, same_as: same_as, cross_species_exact: cross_species_exact, cross_species_narrow: cross_species_broad, cross_species_broad: cross_species_narrow, deprotonated_form_of: protonated_form_of, protonated_form_of: deprotonated_form_of, orthologous_to: orthologous_to, part_of: has_part, has_part: part_of, has_suborganization: is_suborganization_of, is_suborganization_of: has_suborganization, derives_from: derives_into, derives_into: derives_from, located_in: location_of, location_of: located_in, enabled_by: enables, enables: enabled_by, } semantic_mapping_inversions = inversions biopragmatics-curies-aa8bd37/src/curies/w3c.py000066400000000000000000000123621525104130300214460ustar00rootroot00000000000000"""Validation based on W3C standards. The Worldwide Web Consortium (W3C) provides standards for `prefixes `_ (i.e., ``NCName``), `CURIEs `_, and `IRIs `_, but they are highly obfuscated and spread across many documents. This module attempts to operationalize these standards, along with best practices of documentation and testing. .. seealso:: Some other work towards operationalizing these standards: - https://github.com/linkml/linkml-runtime/blob/main/linkml_runtime/utils/uri_validator.py - https://github.com/dgerber/rfc3987/blob/gh-archived/rfc3987.py """ import re __all__ = [ "CURIE_PATTERN", "CURIE_RE", "LOCAL_UNIQUE_IDENTIFIER_PATTERN", "LOCAL_UNIQUE_IDENTIFIER_RE", "NCNAME_PATTERN", "NCNAME_RE", "is_w3c_curie", "is_w3c_prefix", ] NCNAME_PATTERN = r"[A-Za-z_][A-Za-z0-9\.\-_]*" """A regex for prefixes, from https://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-NCName. .. code-block:: prefix ::= NCName NCName ::= (Letter | '_') (NCNameChar)* NCNameChar ::= Letter | Digit | '.' | '-' | '_' """ NCNAME_RE = re.compile(f"^{NCNAME_PATTERN}$") LOCAL_UNIQUE_IDENTIFIER_PATTERN = r"(/[^\s/][^\s]*|[^\s/][^\s]*|[^\s]?)" """A regex for local unique identifiers in CURIEs, based on https://www.ietf.org/rfc/rfc3987.txt This pattern was adapted from https://gist.github.com/niklasl/2506955, which sort of implements RFC3987, """ LOCAL_UNIQUE_IDENTIFIER_RE = re.compile(LOCAL_UNIQUE_IDENTIFIER_PATTERN) CURIE_PATTERN = rf"^({NCNAME_PATTERN}?:)?{LOCAL_UNIQUE_IDENTIFIER_PATTERN}$" """A regex for CURIEs, based on https://www.w3.org/TR/2010/NOTE-curie-20101216. .. code-block:: curie := [ [ prefix ] ':' ] reference prefix := NCName reference := irelative-ref (as defined in `IRI `_) `irelative-ref` is defined/documented in :data:`curies.w3c.LOCAL_UNIQUE_IDENTIFIER_PATTERN`. """ CURIE_RE = re.compile(CURIE_PATTERN) def is_w3c_prefix(prefix: str) -> bool: """Return if the string is a valid prefix under the W3C specification. :param prefix: A string :returns: If the string is a valid prefix under the W3C specification. Validation is implemented as a regular expression match against :data:`curies.w3c.NCNAME_PATTERN`, as defined by the W3C `here `_. Examples -------- Strings containig numbers, letters, and underscores are valid prefixes. >>> is_w3c_prefix("GO") True The W3C specification states that the prefix '_' is reserved for use by languages that support RDF. For this reason, the prefix '_' SHOULD be avoided by authors. >>> is_w3c_prefix("_") True Strings starting with a number are not valid prefixes. >>> is_w3c_prefix("3dmet") Strings containing a colon or other characters are invalid >>> is_w3c_prefix("GO:") False """ return bool(NCNAME_RE.match(prefix)) def _is_w3c_luid(luid: str) -> bool: return bool(LOCAL_UNIQUE_IDENTIFIER_RE.match(luid)) def is_w3c_curie(curie: str) -> bool: """Return if the string is a valid CURIE under the W3C specification. :param curie: A string to check if it is a valid CURIE under the W3C specification. :returns: True if the string is a valid CURIE under the W3C specification. .. warning:: This is slightly different from the :meth:`curies.Converter.is_curie` function, which checks if a given CURIE is valid under the extended prefix map contained within the converter. Further, the base converter is slightly more lenient than the W3C specification by default to allow for the inclusion of CURIEs, e.g., for SMILES strings like ``smiles:CC(=O)NC([H])(C)C(=O)O``. These are useful, but not technically valid due to their inclusion of brackets. Examples -------- If no prefix is given, the host language chooses how to assign a default prefix. >>> is_w3c_curie(":test") True From the specification, regarding using an underscore as the prefix The CURIE prefix '_' is reserved for use by languages that support RDF. For this reason, the prefix '_' SHOULD be avoided by authors. >>> is_w3c_curie("_:test") True This is invalid because a CURIE prefix isn't allowed to start with a number. It has to start with either a letter, or an underscore. >>> is_w3c_curie("4cdn:test") False Empty strings are explicitly noted as being invalid. >>> is_w3c_curie("") False """ if "[" in curie or "]" in curie: return False # empty curie is invalid (for now) if not curie.strip(): return False # if there's no colon, then validate the whole thing against the LUID pattern. # this is because prefix, sep, identifier = curie.partition(":") if not sep: return _is_w3c_luid(curie) # it's okay for there to be no prefix in a CURIE, even though # the NCName definition is not itself allowed to be empty if not prefix: return _is_w3c_luid(identifier) return is_w3c_prefix(prefix) and _is_w3c_luid(identifier) biopragmatics-curies-aa8bd37/tests/000077500000000000000000000000001525104130300174555ustar00rootroot00000000000000biopragmatics-curies-aa8bd37/tests/__init__.py000066400000000000000000000000371525104130300215660ustar00rootroot00000000000000"""Tests for :mod:`curies`.""" biopragmatics-curies-aa8bd37/tests/constants.py000066400000000000000000000002021525104130300220350ustar00rootroot00000000000000"""Constants for testing.""" import unittest RUN_SLOW = True SLOW = unittest.skipUnless(RUN_SLOW, reason="Skipping slow tests") biopragmatics-curies-aa8bd37/tests/resources/000077500000000000000000000000001525104130300214675ustar00rootroot00000000000000biopragmatics-curies-aa8bd37/tests/resources/invalid_curies.txt000066400000000000000000000000771525104130300252340ustar00rootroot00000000000000 smiles:CC(=O)NC([H])(C)C(=O)O 4cdn:test #nope:nope ?nope:nope biopragmatics-curies-aa8bd37/tests/resources/invalid_prefixes.txt000066400000000000000000000000421525104130300255570ustar00rootroot00000000000000 4dn GO:GO: GO: #nope $ # : :luid biopragmatics-curies-aa8bd37/tests/resources/valid_curies.txt000066400000000000000000000002371525104130300247030ustar00rootroot00000000000000pfx:abc : pfx: abc :abc _:abc pfx:/abc pfx:/ :/ bioregistry:bioregistry GO:0000012 go:0123456 home:#start joseki: google:xforms+or+'xml+forms' isbn:0321154991 biopragmatics-curies-aa8bd37/tests/resources/valid_prefixes.txt000066400000000000000000000001001525104130300252230ustar00rootroot00000000000000go GO NCBITaxon ncbi.taxon ncbi_taxon _ _secret secret_ _secret biopragmatics-curies-aa8bd37/tests/test_api.py000066400000000000000000001523631525104130300216510ustar00rootroot00000000000000"""Trivial version test.""" from __future__ import annotations import datetime import json import tempfile import unittest from pathlib import Path from tempfile import TemporaryDirectory from typing import Literal, overload import httpx import pandas as pd import rdflib from pydantic import AnyUrl from rdflib import URIRef import curies from curies import vocabulary as v from curies.api import ( CompressionError, Converter, CURIEStandardizationError, DuplicatePrefixes, DuplicateURIPrefixes, ExpansionError, PrefixStandardizationError, Record, Reference, ReferenceTuple, URIStandardizationError, URIType, chain, upgrade_prefix_map, ) from curies.sources import ( BIOREGISTRY_CONTEXTS, get_bioregistry_converter, get_go_converter, get_monarch_converter, get_obo_converter, ) from curies.version import get_version from curies.vocabulary import parse_xsd from tests.constants import SLOW CHEBI_URI_PREFIX = "http://purl.obolibrary.org/obo/CHEBI_" GO_URI_PREFIX = "http://purl.obolibrary.org/obo/GO_" class TestAddRecord(unittest.TestCase): """Test adding records.""" def setUp(self) -> None: """Set up the test case.""" self.prefix = "CHEBI" self.uri_prefix = CHEBI_URI_PREFIX self.prefix_synonym = "p" self.uri_prefix_synonym = "u" self.converter = Converter.from_extended_prefix_map( [ { "prefix": self.prefix, "prefix_synonyms": [self.prefix_synonym], "uri_prefix": self.uri_prefix, "uri_prefix_synonyms": [self.uri_prefix_synonym], }, ] ) def test_duplicate_failure(self) -> None: """Test failure caused by double matching.""" self.converter.add_prefix("GO", GO_URI_PREFIX) with self.assertRaises(ValueError): self.converter.add_record(Record(prefix="GO", uri_prefix=CHEBI_URI_PREFIX)) def test_get_prefix_synonyms(self) -> None: """Test getting prefix synonyms.""" self.assertEqual({self.prefix}, self.converter.get_prefixes()) self.assertEqual({self.prefix}, self.converter.get_prefixes(include_synonyms=False)) self.assertEqual( {self.prefix, self.prefix_synonym}, self.converter.get_prefixes(include_synonyms=True), ) def test_get_uri_prefix_synonyms(self) -> None: """Test getting URI prefix synonyms.""" self.assertEqual({self.uri_prefix}, self.converter.get_uri_prefixes()) self.assertEqual({self.uri_prefix}, self.converter.get_uri_prefixes(include_synonyms=False)) self.assertEqual( {self.uri_prefix, self.uri_prefix_synonym}, self.converter.get_uri_prefixes(include_synonyms=True), ) def test_extend_on_prefix_match(self) -> None: """Test adding a new prefix in merge mode.""" s1, s2, s3 = "s1", "s2", "s3" for record in [ Record( prefix="CHEBI", prefix_synonyms=[s1], uri_prefix=s2, uri_prefix_synonyms=[s3], ), Record( prefix=s1, prefix_synonyms=["CHEBI"], uri_prefix=s2, uri_prefix_synonyms=[s3], ), ]: with self.assertRaises(ValueError): self.converter.add_record(record, merge=False) self.converter.add_record(record, merge=True) self.assertEqual(1, len(self.converter.records)) record = self.converter.records[0] self.assertEqual("CHEBI", record.prefix) self.assertEqual({s1, self.prefix_synonym}, set(record.prefix_synonyms)) self.assertEqual(CHEBI_URI_PREFIX, record.uri_prefix) self.assertEqual({s2, s3, self.uri_prefix_synonym}, set(record.uri_prefix_synonyms)) def test_extend_on_uri_prefix_match(self) -> None: """Test adding a new prefix in merge mode.""" s1, s2, s3 = "s1", "s2", "s3" for record in [ Record( prefix=s1, prefix_synonyms=[s3], uri_prefix=s2, uri_prefix_synonyms=[CHEBI_URI_PREFIX], ), Record( prefix=s1, prefix_synonyms=[s3], uri_prefix=CHEBI_URI_PREFIX, uri_prefix_synonyms=[s2], ), ]: with self.assertRaises(ValueError): self.converter.add_record(record, merge=False) self.converter.add_record(record, merge=True) self.assertEqual(1, len(self.converter.records)) record = self.converter.records[0] self.assertEqual("CHEBI", record.prefix) self.assertEqual({s1, s3, self.prefix_synonym}, set(record.prefix_synonyms)) self.assertEqual(CHEBI_URI_PREFIX, record.uri_prefix) self.assertEqual({s2, self.uri_prefix_synonym}, set(record.uri_prefix_synonyms)) def test_extend_on_prefix_synonym_match(self) -> None: """Test adding a new prefix in merge mode.""" s1, s2, s3 = "s1", "s2", "s3" for record in [ Record( prefix=self.prefix_synonym, prefix_synonyms=[s1], uri_prefix=s2, uri_prefix_synonyms=[s3], ), Record( prefix=s1, prefix_synonyms=[self.prefix_synonym], uri_prefix=s2, uri_prefix_synonyms=[s3], ), ]: self.converter.add_record(record, merge=True) self.assertEqual(1, len(self.converter.records)) record = self.converter.records[0] self.assertEqual("CHEBI", record.prefix) self.assertEqual({s1, self.prefix_synonym}, set(record.prefix_synonyms)) self.assertEqual(CHEBI_URI_PREFIX, record.uri_prefix) self.assertEqual({s2, s3, self.uri_prefix_synonym}, set(record.uri_prefix_synonyms)) def test_extend_on_uri_prefix_synonym_match(self) -> None: """Test adding a new prefix in merge mode.""" s1, s2, s3 = "s1", "s2", "s3" for record in [ Record( prefix=s1, prefix_synonyms=[s2], uri_prefix=self.uri_prefix_synonym, uri_prefix_synonyms=[s3], ), Record( prefix=s1, prefix_synonyms=[s2], uri_prefix=s3, uri_prefix_synonyms=[self.uri_prefix_synonym], ), ]: self.converter.add_record(record, merge=True) self.assertEqual(1, len(self.converter.records)) record = self.converter.records[0] self.assertEqual("CHEBI", record.prefix) self.assertEqual({s1, s2, self.prefix_synonym}, set(record.prefix_synonyms)) self.assertEqual(CHEBI_URI_PREFIX, record.uri_prefix) self.assertEqual({s3, self.uri_prefix_synonym}, set(record.uri_prefix_synonyms)) def test_extend_on_prefix_match_ci(self) -> None: """Test adding a new prefix in merge mode.""" s1, s2, s3 = "s1", "s2", "s3" record = Record( prefix="chebi", prefix_synonyms=[s1], uri_prefix=s2, uri_prefix_synonyms=[s3] ) self.converter.add_record(record, case_sensitive=False, merge=True) self.assertEqual(1, len(self.converter.records)) record = self.converter.records[0] self.assertEqual("CHEBI", record.prefix) self.assertEqual({"chebi", s1, self.prefix_synonym}, set(record.prefix_synonyms)) self.assertEqual(CHEBI_URI_PREFIX, record.uri_prefix) self.assertEqual({s2, s3, self.uri_prefix_synonym}, set(record.uri_prefix_synonyms)) class TestConverter(unittest.TestCase): """Test the converter class.""" def setUp(self) -> None: """Set up the converter test case.""" self.simple_obo_prefix_map = { "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", "MONDO": "http://purl.obolibrary.org/obo/MONDO_", "GO": "http://purl.obolibrary.org/obo/GO_", "OBO": "http://purl.obolibrary.org/obo/", } self.converter = Converter.from_prefix_map(self.simple_obo_prefix_map) def test_iter(self) -> None: """Test the iterator.""" self.assertEqual(self.converter.records, list(self.converter)) def test_reference_tuple(self) -> None: """Test the reference tuple data type.""" t = ReferenceTuple("chebi", "1234") self.assertEqual("chebi:1234", t.curie) self.assertEqual(t, ReferenceTuple.from_curie("chebi:1234")) def test_reference_pydantic(self) -> None: """Test the reference Pydantic model.""" t = Reference(prefix="chebi", identifier="1234") self.assertEqual("chebi:1234", t.curie) self.assertEqual(t, Reference.from_curie("chebi:1234")) def test_invalid_record(self) -> None: """Test throwing an error for invalid records.""" with self.assertRaises(ValueError): Record( prefix="chebi", uri_prefix="http://purl.obolibrary.org/obo/CHEBI_", prefix_synonyms=["chebi"], ) with self.assertRaises(ValueError): Record( prefix="chebi", uri_prefix="http://purl.obolibrary.org/obo/CHEBI_", uri_prefix_synonyms=["http://purl.obolibrary.org/obo/CHEBI_"], ) def test_invalid_records(self) -> None: """Test throwing an error for duplicated URI prefixes.""" with self.assertRaises(DuplicateURIPrefixes) as e: curies.load_prefix_map( { "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", "nope": "http://purl.obolibrary.org/obo/CHEBI_", } ) self.assertIsInstance(str(e.exception), str) with self.assertRaises(DuplicatePrefixes) as e2: Converter( [ Record(prefix="chebi", uri_prefix="https://bioregistry.io/chebi:"), Record(prefix="chebi", uri_prefix="http://purl.obolibrary.org/obo/CHEBI_"), ], ) self.assertIsInstance(str(e2.exception), str) # No failure Converter.from_prefix_map( { "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", "nope": "http://purl.obolibrary.org/obo/CHEBI_", }, strict=False, ) def test_subset(self) -> None: """Test subsetting a converter.""" new_converter = self.converter.get_subconverter(["CHEBI"]) self.assertEqual(1, len(new_converter.records)) self.assertEqual({"CHEBI"}, new_converter.get_prefixes()) self.assertEqual( {"http://purl.obolibrary.org/obo/CHEBI_"}, new_converter.get_uri_prefixes() ) self.assertEqual({"CHEBI"}, set(new_converter.bimap)) self.assertEqual({"CHEBI"}, set(new_converter.prefix_map)) self.assertEqual( {"http://purl.obolibrary.org/obo/CHEBI_"}, set(new_converter.reverse_prefix_map) ) def test_empty_subset(self) -> None: """Test subsetting a converter and getting an empty one back.""" new_converter_2 = self.converter.get_subconverter(["NOPE"]) self.assertEqual(0, len(new_converter_2.records)) def test_predicates(self) -> None: """Add tests for predicates.""" self.assertFalse(self.converter.is_uri("")) self.assertFalse(self.converter.is_uri("nope")) self.assertFalse(self.converter.is_curie("")) self.assertFalse(self.converter.is_curie("nope")) self.assertFalse(self.converter.is_curie(":nope")) self.assertFalse(self.converter.is_curie("nope:")) def test_convert(self) -> None: """Test compression.""" self.assertEqual({"CHEBI", "MONDO", "GO", "OBO"}, self.converter.get_prefixes()) self.assertEqual( { "http://purl.obolibrary.org/obo/CHEBI_", "http://purl.obolibrary.org/obo/MONDO_", "http://purl.obolibrary.org/obo/GO_", "http://purl.obolibrary.org/obo/", }, self.converter.get_uri_prefixes(), ) self._assert_convert(self.converter) def _assert_convert(self, converter: Converter) -> None: self.assertIn("GO", converter.prefix_map) self.assertTrue(converter.has_prefix("GO")) self.assertFalse(converter.has_prefix("nope-nope-nope")) self.assertIn("GO", converter.bimap) self.assertIn("GO", converter.reverse_bimap.values()) self.assertIn("http://purl.obolibrary.org/obo/GO_", converter.reverse_prefix_map) self.assertIn("http://purl.obolibrary.org/obo/GO_", converter.reverse_bimap) self.assertIn("http://purl.obolibrary.org/obo/GO_", converter.trie) self.assertNotIn("http://purl.obolibrary.org/obo/XXX_", converter.trie) self.assertIn("http://purl.obolibrary.org/obo/GO_", converter.bimap.values()) for curie, uri in [ ("CHEBI:1", "http://purl.obolibrary.org/obo/CHEBI_1"), ("OBO:unnamespaced", "http://purl.obolibrary.org/obo/unnamespaced"), ]: self.assertTrue(converter.is_uri(uri)) self.assertTrue(converter.is_curie(curie)) self.assertFalse(converter.is_curie(uri)) self.assertFalse(converter.is_uri(curie)) self.assertEqual(curie, converter.compress(uri)) self.assertEqual(curie, converter.compress_strict(uri)) self.assertEqual(uri, converter.expand(curie)) self.assertEqual(uri, converter.expand_strict(curie)) self.assertIsNone(converter.compress("http://example.org/missing:00000")) self.assertEqual( "http://example.org/missing:00000", converter.compress("http://example.org/missing:00000", passthrough=True), ) with self.assertRaises(CompressionError): converter.compress_strict("http://example.org/missing:00000") self.assertIsNone(converter.expand("missing:00000")) self.assertEqual("missing:00000", converter.expand("missing:00000", passthrough=True)) with self.assertRaises(ExpansionError): converter.expand_strict("missing:00000") self.assertLess(0, len(converter.records), msg="converter has no records") self.assertIsNone(converter.get_record("nope")) self.assertIsNone(converter.get_record("go"), msg="synonym lookup is not allowed here") record = converter.get_record("GO", strict=True) self.assertIsNotNone(record, msg=f"records: {[r.prefix for r in converter.records]}") self.assertIsInstance(record, Record) self.assertEqual("GO", record.prefix) @SLOW @unittest.skip("problem with bioregistry getter") def test_bioregistry(self) -> None: """Test loading a remote JSON-LD context.""" for web in [True, False]: bioregistry_converter = get_bioregistry_converter(web=web) self.assert_bioregistry_converter(bioregistry_converter) c = Converter.from_reverse_prefix_map(f"{BIOREGISTRY_CONTEXTS}/bioregistry.rpm.json") self.assertIn("chebi", c.prefix_map) self.assertNotIn("CHEBI", c.prefix_map) def test_jsonld(self) -> None: """Test parsing JSON-LD context.""" context = { "@context": { "@version": "1.0.0", # should skip this "": "", # should skip this "hello": "https://example.org/hello:", "CHEBI": { "@prefix": True, "@id": "http://purl.obolibrary.org/CHEBI_", }, "nope": { "nope": "nope", }, }, } converter = Converter.from_jsonld(context) self.assertIn("hello", converter.prefix_map) self.assertIn("CHEBI", converter.prefix_map) @SLOW def test_from_github(self) -> None: """Test getting a JSON-LD map from GitHub.""" with self.assertRaises(ValueError): # missing end .jsonld file Converter.from_jsonld_github("biopragmatics", "bioregistry") semweb_converter = Converter.from_jsonld_github( "biopragmatics", "bioregistry", "exports", "contexts", "semweb.context.jsonld" ) self.assertIn("rdf", semweb_converter.prefix_map) @SLOW def test_obo(self) -> None: """Test the OBO converter.""" obo_converter = get_obo_converter() self.assertIn("CHEBI", obo_converter.prefix_map) self.assertTrue(obo_converter.has_prefix("CHEBI")) self.assertNotIn("chebi", obo_converter.prefix_map) self.assertFalse(obo_converter.has_prefix("chebi")) @SLOW def test_monarch(self) -> None: """Test the Monarch converter.""" monarch_converter = get_monarch_converter() self.assertIn("CHEBI", monarch_converter.prefix_map) self.assertNotIn("chebi", monarch_converter.prefix_map) @SLOW def test_go_registry(self) -> None: """Test the GO registry converter.""" go_converter = get_go_converter() self.assertIn("CHEBI", go_converter.prefix_map) self.assertNotIn("chebi", go_converter.prefix_map) def assert_bioregistry_converter(self, converter: Converter) -> None: """Assert the bioregistry converter has the right stuff in it.""" records = {records.prefix: records for records in converter.records} self.assertIn("chebi", records) record = records["chebi"] self.assertIsInstance(record, Record) self.assertEqual("chebi", record.prefix) self.assertIn("CHEBI", record.prefix_synonyms) self.assertIn("ChEBI", record.prefix_synonyms) self.assertIn("chebi", converter.prefix_map) self.assertIn("chebi", converter.bimap) # Synonyms that are non-conflicting also get added self.assertIn("CHEBI", converter.prefix_map) self.assertNotIn("CHEBI", converter.bimap) chebi_uri = converter.prefix_map["chebi"] self.assertIn(chebi_uri, converter.reverse_prefix_map) self.assertEqual("chebi", converter.reverse_prefix_map[chebi_uri]) self.assertTrue(converter.has_prefix("CHEBI")) self.assertTrue(converter.has_prefix("chebi")) def test_load_path(self) -> None: """Test loading from paths.""" with tempfile.TemporaryDirectory() as directory: path = Path(directory).joinpath("pm.json") with self.assertRaises(FileNotFoundError): Converter.from_prefix_map(path) with self.assertRaises(FileNotFoundError): Converter.from_prefix_map(str(path)) path.write_text(json.dumps(self.converter.prefix_map)) c1 = Converter.from_prefix_map(path) self.assertEqual(self.converter.prefix_map, c1.prefix_map) c2 = Converter.from_prefix_map(str(path)) self.assertEqual(self.converter.prefix_map, c2.prefix_map) def test_reverse_constructor(self) -> None: """Test constructing from a reverse prefix map.""" converter = Converter.from_reverse_prefix_map( { "http://purl.obolibrary.org/obo/CHEBI_": "CHEBI", "https://www.ebi.ac.uk/chebi/searchId.do?chebiId=": "CHEBI", "http://purl.obolibrary.org/obo/MONDO_": "MONDO", } ) self.assertEqual( "http://purl.obolibrary.org/obo/CHEBI_138488", converter.expand("CHEBI:138488") ) self.assertEqual( "CHEBI:138488", converter.compress("http://purl.obolibrary.org/obo/CHEBI_138488") ) self.assertEqual( "CHEBI:138488", converter.compress("https://www.ebi.ac.uk/chebi/searchId.do?chebiId=138488"), ) def test_standardize_curie(self) -> None: """Test standardize CURIE.""" converter = Converter.from_extended_prefix_map( [ Record( prefix="CHEBI", prefix_synonyms=["chebi"], uri_prefix="http://purl.obolibrary.org/obo/CHEBI_", uri_prefix_synonyms=[ "https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:", ], ), ] ) self.assertEqual("CHEBI:138488", converter.standardize_curie("chebi:138488")) self.assertEqual("CHEBI:138488", converter.standardize_curie("CHEBI:138488")) self.assertIsNone(converter.standardize_curie("NOPE:NOPE")) self.assertEqual("NOPE:NOPE", converter.standardize_curie("NOPE:NOPE", passthrough=True)) with self.assertRaises(CURIEStandardizationError): converter.standardize_curie("NOPE:NOPE", strict=True) self.assertEqual( "http://purl.obolibrary.org/obo/CHEBI_138488", converter.standardize_uri( "https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:138488" ), ) self.assertEqual( "http://purl.obolibrary.org/obo/CHEBI_138488", converter.standardize_uri("http://purl.obolibrary.org/obo/CHEBI_138488"), ) self.assertIsNone(converter.standardize_uri("NOPE")) self.assertEqual("NOPE", converter.standardize_uri("NOPE", passthrough=True)) with self.assertRaises(URIStandardizationError): converter.standardize_uri("NOPE:NOPE", strict=True) def test_standardize_reference(self) -> None: """Test standardize reference.""" converter = Converter.from_extended_prefix_map( [ Record( prefix="CHEBI", prefix_synonyms=["chebi"], uri_prefix="http://purl.obolibrary.org/obo/CHEBI_", ), ] ) r1 = Reference.from_curie("chebi:138488") r2 = Reference.from_curie("CHEBI:138488") bad = Reference.from_curie("NOPE:NOPE") for r in [r1, r2]: self.assertEqual(r2, converter.standardize_reference(r)) self.assertEqual(r2, converter.standardize_reference(r, strict=True)) self.assertEqual(r2, converter.standardize_reference(r, strict=False)) self.assertIsNone(converter.standardize_reference(bad)) self.assertIsNone(converter.standardize_reference(bad, strict=False)) with self.assertRaises(PrefixStandardizationError): converter.standardize_reference(bad, strict=True) def test_combine(self) -> None: """Test chaining converters.""" with self.assertRaises(ValueError): chain([]) c1 = Converter.from_priority_prefix_map( { "CHEBI": ["http://purl.obolibrary.org/obo/CHEBI_", "https://bioregistry.io/chebi:"], "MONDO": ["http://purl.obolibrary.org/obo/MONDO_"], } ) c2 = Converter.from_priority_prefix_map( { "CHEBI": [ "https://www.ebi.ac.uk/chebi/searchId.do?chebiId=", "http://identifiers.org/chebi/", "http://purl.obolibrary.org/obo/CHEBI_", ], "GO": ["http://purl.obolibrary.org/obo/GO_"], "OBO": ["http://purl.obolibrary.org/obo/"], } ) converter = chain([c1, c2], case_sensitive=True) self.assertEqual("CHEBI", converter.get_record("CHEBI").prefix) for url in [ "http://purl.obolibrary.org/obo/CHEBI_138488", "https://bioregistry.io/chebi:138488", "http://identifiers.org/chebi/138488", "https://www.ebi.ac.uk/chebi/searchId.do?chebiId=138488", ]: self.assertEqual("CHEBI:138488", converter.compress(url)) self.assertEqual("GO", converter.get_record("GO").prefix) self.assertEqual( "GO:0000001", converter.compress("http://purl.obolibrary.org/obo/GO_0000001"), ) self.assertEqual( "http://purl.obolibrary.org/obo/CHEBI_", converter.get_record("CHEBI").uri_prefix ) self.assertIn("CHEBI", converter.prefix_map) self.assertEqual("http://purl.obolibrary.org/obo/CHEBI_", converter.prefix_map["CHEBI"]) self.assertEqual( "http://purl.obolibrary.org/obo/CHEBI_138488", converter.expand("CHEBI:138488"), ) self.assertNotIn("nope", converter.get_prefixes()) def test_combine_with_synonyms(self) -> None: """Test combination with synonyms.""" r1 = Record(prefix="GO", uri_prefix=GO_URI_PREFIX) r2 = Record(prefix="go", prefix_synonyms=["GO"], uri_prefix="https://identifiers.org/go:") c1 = Converter([]) c1.add_record(r1) self.assertEqual(c1.records, Converter([r1]).records) c1.add_record(r2, merge=True) self.assertEqual(1, len(c1.records)) r = c1.records[0] self.assertEqual("GO", r.prefix) self.assertEqual({"go"}, set(r.prefix_synonyms)) self.assertEqual("http://purl.obolibrary.org/obo/GO_", r.uri_prefix) self.assertEqual({"https://identifiers.org/go:"}, set(r.uri_prefix_synonyms)) c3 = chain([Converter([r1]), Converter([r2])]) self.assertEqual(1, len(c3.records)) self.assertIn("GO", c3.prefix_map) self.assertIn("go", c3.prefix_map, msg=f"PM: {c3.prefix_map}") self.assertNotIn("go", c3.bimap) self.assertIn("GO", c3.bimap) self.assertTrue(c3.has_prefix("go")) self.assertTrue(c3.has_prefix("GO")) self.assertFalse(c3.has_prefix("nope")) def test_combine_ci(self) -> None: """Test combining case-insensitive.""" c1 = Converter.from_priority_prefix_map( { "CHEBI": [ "http://purl.obolibrary.org/obo/CHEBI_", "https://bioregistry.io/chebi:", ], } ) c2 = Converter.from_reverse_prefix_map( { "http://identifiers.org/chebi/": "chebi", "http://identifiers.org/chebi:": "chebi", } ) converter = chain([c1, c2], case_sensitive=False) self.assertEqual({"CHEBI"}, converter.get_prefixes()) self.assertEqual({"CHEBI"}, converter.get_prefixes(include_synonyms=False)) self.assertEqual({"CHEBI", "chebi"}, converter.get_prefixes(include_synonyms=True)) for url in [ "http://purl.obolibrary.org/obo/CHEBI_138488", "http://identifiers.org/chebi/138488", "http://identifiers.org/chebi:138488", "https://bioregistry.io/chebi:138488", ]: self.assertEqual("CHEBI:138488", converter.compress(url)) # use the first prefix map for expansions self.assertEqual( "http://purl.obolibrary.org/obo/CHEBI_138488", converter.expand("CHEBI:138488"), ) def test_combine_with_patterns(self) -> None: """Test chaining with patterns.""" c1 = Converter([Record(prefix="a", uri_prefix="https://example.org/a/", pattern="^\\d{7}")]) c2 = Converter([Record(prefix="a", uri_prefix="https://example.org/a/", pattern="^\\d+")]) converter = chain([c1, c2]) self.assertEqual( [Record(prefix="a", uri_prefix="https://example.org/a/", pattern="^\\d{7}")], converter.records, ) def test_combine_with_patterns_via_synonym(self) -> None: """Test chaining with patterns.""" c1 = Converter([Record(prefix="a", uri_prefix="https://example.org/a/", pattern="^\\d{7}")]) c2 = Converter( [ Record( prefix="b", prefix_synonyms=["a"], uri_prefix="https://example.org/b/", pattern="^\\d+", ) ] ) converter = chain([c1, c2]) self.assertEqual( [ Record( prefix="a", prefix_synonyms=["b"], uri_prefix="https://example.org/a/", uri_prefix_synonyms=["https://example.org/b/"], pattern="^\\d{7}", ) ], converter.records, ) def test_df_bulk(self) -> None: """Test bulk processing in pandas dataframes.""" rows = [ ("CHEBI:1", "http://purl.obolibrary.org/obo/CHEBI_1"), ] df = pd.DataFrame(rows, columns=["curie", "uri"]) self.converter.pd_expand(df, "curie") self.assertTrue((df.curie == df.uri).all()) df = pd.DataFrame(rows, columns=["curie", "uri"]) self.converter.pd_compress(df, "uri") self.assertTrue((df.curie == df.uri).all()) def test_df_standardize(self) -> None: """Test standardizing dataframes.""" converter = Converter([]) converter.add_prefix( "chebi", "http://purl.obolibrary.org/obo/CHEBI_", prefix_synonyms=["CHEBI"], uri_prefix_synonyms=["https://bioregistry.io/chebi:"], ) self.assertEqual("chebi", converter.standardize_prefix("chebi")) self.assertEqual("chebi", converter.standardize_prefix("CHEBI")) self.assertIsNone(converter.standardize_prefix("nope")) self.assertEqual("nope", converter.standardize_prefix("nope", passthrough=True)) with self.assertRaises(PrefixStandardizationError): converter.standardize_prefix("nope", strict=True) rows = [ ("chebi", "CHEBI:1", "http://purl.obolibrary.org/obo/CHEBI_1"), ("CHEBI", "CHEBI:2", "https://bioregistry.io/chebi:2"), ] df = pd.DataFrame(rows, columns=["prefix", "curie", "uri"]) converter.pd_standardize_prefix(df, column="prefix") self.assertEqual(["chebi", "chebi"], list(df["prefix"]), msg=f"\n\n{df}") converter.pd_standardize_curie(df, column="curie") self.assertEqual(["chebi:1", "chebi:2"], list(df["curie"])) converter.pd_standardize_uri(df, column="uri") self.assertEqual( ["http://purl.obolibrary.org/obo/CHEBI_1", "http://purl.obolibrary.org/obo/CHEBI_2"], list(df["uri"]), ) def test_file_bulk(self) -> None: """Test bulk processing of files.""" with TemporaryDirectory() as directory: for rows, header in [ ( [ ("curie", "uri"), ("CHEBI:1", "http://purl.obolibrary.org/obo/CHEBI_1"), ], True, ), ( [ ("CHEBI:1", "http://purl.obolibrary.org/obo/CHEBI_1"), ], False, ), ]: path = Path(directory).joinpath("test.tsv") with path.open("w") as file: for row in rows: print(*row, sep="\t", file=file) idx = 1 if header else 0 self.converter.file_expand(path, 0, header=header) lines = [line.strip().split("\t") for line in path.read_text().splitlines()] self.assertEqual("http://purl.obolibrary.org/obo/CHEBI_1", lines[idx][0]) self.converter.file_compress(path, 0, header=header) lines = [line.strip().split("\t") for line in path.read_text().splitlines()] self.assertEqual("CHEBI:1", lines[idx][0]) def test_incremental(self) -> None: """Test building a converter from an incremental interface.""" converter = Converter([]) for prefix, uri_prefix in self.simple_obo_prefix_map.items(): converter.add_prefix(prefix, uri_prefix) converter.add_prefix( "hgnc", "https://bioregistry.io/hgnc:", prefix_synonyms=["HGNC"], uri_prefix_synonyms=["https://identifiers.org/hgnc:"], ) self._assert_convert(converter) self.assertEqual( "hgnc:1234", converter.compress("https://bioregistry.io/hgnc:1234"), ) self.assertEqual( "hgnc:1234", converter.compress("https://identifiers.org/hgnc:1234"), ) self.assertEqual("https://bioregistry.io/hgnc:1234", converter.expand("HGNC:1234")) with self.assertRaises(ValueError): converter.add_prefix("GO", "...") with self.assertRaises(ValueError): converter.add_prefix("...", "http://purl.obolibrary.org/obo/GO_") with self.assertRaises(ValueError): converter.add_prefix( "...", "...", uri_prefix_synonyms=["http://purl.obolibrary.org/obo/GO_"] ) with self.assertRaises(ValueError): converter.add_prefix("...", "...", prefix_synonyms=["GO"]) def test_rdflib(self) -> None: """Test parsing a converter from an RDFLib object.""" graph = rdflib.Graph() for prefix, uri_prefix in self.simple_obo_prefix_map.items(): graph.bind(prefix, uri_prefix) converter = Converter.from_rdflib(graph) self._assert_convert(converter) converter_2 = Converter.from_rdflib(graph.namespace_manager) self._assert_convert(converter_2) def test_parse_curie(self) -> None: """Tests for parse CURIE.""" converter = Converter( records=[ Record( prefix="GO", uri_prefix="http://purl.obolibrary.org/obo/GO_", prefix_synonyms=["go"], ) ] ) self.assertEqual( ReferenceTuple("GO", "1234567"), converter.parse_curie("GO:1234567", strict=True) ) self.assertEqual( ReferenceTuple("GO", "1234567"), converter.parse_curie("GO:1234567", strict=False) ) self.assertEqual( ReferenceTuple("GO", "1234567"), converter.parse_curie("go:1234567", strict=True) ) self.assertEqual( ReferenceTuple("GO", "1234567"), converter.parse_curie("go:1234567", strict=False) ) self.assertIsNone(converter.parse_curie("NOPE:NOPE", strict=False)) with self.assertRaises(PrefixStandardizationError): converter.parse_curie("NOPE:NOPE", strict=True) def test_parse(self) -> None: """Test parsing URI or CURIE.""" converter = Converter( records=[ Record( prefix="GO", uri_prefix="http://purl.obolibrary.org/obo/GO_", prefix_synonyms=["go"], uri_prefix_synonyms=["https://identifiers.org/GO:"], ) ] ) curie = "GO:1234567" curie2 = "go:1234567" uri = "http://purl.obolibrary.org/obo/GO_1234567" uri2 = "https://identifiers.org/GO:1234567" for s in [curie, curie2, uri, uri2]: self.assertEqual(ReferenceTuple("GO", "1234567"), converter.parse(s, strict=True)) self.assertEqual(ReferenceTuple("GO", "1234567"), converter.parse(s, strict=False)) # test invalid CURIE parsing self.assertIsNone(converter.parse("NOPE:NOPE", strict=False)) with self.assertRaises(ValueError): converter.parse_uri("NOPE:NOPE", strict=True) # test invalid URI parsing self.assertIsNone(converter.parse("https://example.org/nope", strict=False)) with self.assertRaises(ValueError): converter.parse_uri("https://example.org/nope", strict=True) # test whatever's left self.assertIsNone(converter.parse("1234567", strict=False)) with self.assertRaises(ValueError): converter.parse_uri("1234567", strict=True) def test_compress_or_standardize(self) -> None: """Test standardizing URI or CURIE.""" converter = Converter( records=[ Record( prefix="GO", uri_prefix="http://purl.obolibrary.org/obo/GO_", prefix_synonyms=["go"], uri_prefix_synonyms=["https://identifiers.org/GO:"], ) ] ) curie = "GO:1234567" curie2 = "go:1234567" uri = "http://purl.obolibrary.org/obo/GO_1234567" uri2 = "https://identifiers.org/GO:1234567" for s in [curie, curie2, uri, uri2]: self.assertEqual( "GO:1234567", converter.compress_or_standardize(s, strict=True, passthrough=True) ) self.assertEqual( "GO:1234567", converter.compress_or_standardize(s, strict=False, passthrough=True) ) self.assertEqual( "GO:1234567", converter.compress_or_standardize(s, strict=True, passthrough=False) ) self.assertEqual( "GO:1234567", converter.compress_or_standardize(s, strict=False, passthrough=False) ) self.assertIsNone( converter.compress_or_standardize("NOPE:NOPE", strict=False, passthrough=False) ) self.assertEqual( "NOPE:NOPE", converter.compress_or_standardize("NOPE:NOPE", strict=False, passthrough=True), ) with self.assertRaises(ValueError): converter.compress_or_standardize("NOPE:NOPE", strict=True, passthrough=True) with self.assertRaises(ValueError): converter.compress_or_standardize("NOPE:NOPE", strict=True, passthrough=False) def test_parse_uri(self) -> None: """Tests for parsing URIs.""" converter = Converter( records=[ Record( prefix="GO", uri_prefix="http://purl.obolibrary.org/obo/GO_", prefix_synonyms=["go"], uri_prefix_synonyms=["https://identifiers.org/GO:"], ) ] ) expected = ReferenceTuple("GO", "1234567") uri1 = "http://purl.obolibrary.org/obo/GO_1234567" uri2 = "https://identifiers.org/GO:1234567" uris: list[URIType] = [ uri1, uri2, AnyUrl(uri1), rdflib.URIRef(uri1), httpx.URL(uri1), ] for uri in uris: with self.subTest(uri=str(uri)): self.assertEqual(expected, converter.parse_uri(uri)) self.assertEqual(expected, converter.parse_uri(uri, strict=True)) self.assertEqual(expected, converter.parse_uri(uri, strict=False)) misses: list[URIType] = [ "123345", "https://example.com/12345", AnyUrl("https://example.com/12345"), URIRef("https://example.com/12345"), httpx.URL("https://example.com/12345"), ] for miss in misses: with self.subTest(uri=str(miss)): self.assertIsNone(converter.parse_uri(miss, strict=False)) with self.assertRaises(ValueError): converter.parse_uri(miss, strict=True) def test_expand(self) -> None: """Tests for expand.""" converter = Converter( records=[ Record( prefix="GO", uri_prefix="http://purl.obolibrary.org/obo/GO_", prefix_synonyms=["go"], ) ] ) uri = "http://purl.obolibrary.org/obo/GO_1234567" self.assertEqual(uri, converter.expand("GO:1234567", strict=True, passthrough=True)) self.assertEqual(uri, converter.expand("GO:1234567", strict=False, passthrough=True)) self.assertEqual(uri, converter.expand("GO:1234567", strict=True, passthrough=False)) self.assertEqual(uri, converter.expand("GO:1234567", strict=False, passthrough=False)) self.assertEqual(uri, converter.expand("go:1234567", strict=True, passthrough=True)) self.assertEqual(uri, converter.expand("go:1234567", strict=False, passthrough=True)) self.assertEqual(uri, converter.expand("go:1234567", strict=True, passthrough=False)) self.assertEqual(uri, converter.expand("go:1234567", strict=False, passthrough=False)) self.assertEqual("NOPE:NOPE", converter.expand("NOPE:NOPE", strict=False, passthrough=True)) self.assertIsNone(converter.expand("NOPE:NOPE", strict=False, passthrough=False)) with self.assertRaises(ExpansionError): converter.expand("NOPE:NOPE", strict=True, passthrough=True) with self.assertRaises(ExpansionError): converter.expand("NOPE:NOPE", strict=True, passthrough=False) def test_expand_pair_all(self) -> None: """Tests for expand.""" converter = Converter( records=[ Record( prefix="GO", uri_prefix="http://purl.obolibrary.org/obo/GO_", prefix_synonyms=["go"], uri_prefix_synonyms=["https://identifiers.org/GO:"], ) ] ) uris = ["http://purl.obolibrary.org/obo/GO_1234567", "https://identifiers.org/GO:1234567"] self.assertEqual(uris, converter.expand_pair_all("GO", "1234567", strict=True)) self.assertEqual(uris, converter.expand_pair_all("GO", "1234567", strict=False)) # with synonym as input self.assertEqual(uris, converter.expand_pair_all("go", "1234567", strict=True)) self.assertEqual(uris, converter.expand_pair_all("go", "1234567", strict=False)) self.assertIsNone(converter.expand_pair_all("NOPE", "NOPE", strict=False)) with self.assertRaises(ExpansionError): converter.expand_pair_all("NOPE", "NOPE", strict=True) def test_expand_reference(self) -> None: """Tests for expand.""" converter = Converter( records=[ Record( prefix="GO", uri_prefix="http://purl.obolibrary.org/obo/GO_", prefix_synonyms=["go"], ) ] ) uri = "http://purl.obolibrary.org/obo/GO_1234567" ref = ReferenceTuple("GO", "1234567") ref2 = ReferenceTuple("go", "1234567") nope = ReferenceTuple("NOPE", "NOPE") self.assertEqual(uri, converter.expand_reference(ref, strict=True, passthrough=True)) self.assertEqual(uri, converter.expand_reference(ref, strict=False, passthrough=True)) self.assertEqual(uri, converter.expand_reference(ref, strict=True, passthrough=False)) self.assertEqual(uri, converter.expand_reference(ref, strict=False, passthrough=False)) self.assertEqual(uri, converter.expand_reference(ref2, strict=True, passthrough=True)) self.assertEqual(uri, converter.expand_reference(ref2, strict=False, passthrough=True)) self.assertEqual(uri, converter.expand_reference(ref2, strict=True, passthrough=False)) self.assertEqual(uri, converter.expand_reference(ref2, strict=False, passthrough=False)) self.assertEqual( "NOPE:NOPE", converter.expand_reference(nope, strict=False, passthrough=True) ) self.assertIsNone(converter.expand_reference(nope, strict=False, passthrough=False)) with self.assertRaises(ExpansionError): converter.expand_reference(nope, strict=True, passthrough=True) with self.assertRaises(ExpansionError): converter.expand_reference(nope, strict=True, passthrough=False) def test_expand_all(self) -> None: """Test expand all.""" priority_prefix_map = { "CHEBI": [ "http://purl.obolibrary.org/obo/CHEBI_", "https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:", ], } converter = Converter.from_priority_prefix_map(priority_prefix_map) self.assertEqual( [ "http://purl.obolibrary.org/obo/CHEBI_138488", "https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:138488", ], converter.expand_all("CHEBI:138488"), ) self.assertIsNone(converter.expand_all("NOPE:NOPE")) with self.assertRaises(PrefixStandardizationError): converter.expand_all("NOPE:NOPE", strict=True) def test_expand_ambiguous(self) -> None: """Test expansion of URI or CURIEs.""" converter = Converter.from_extended_prefix_map( [ Record( prefix="CHEBI", prefix_synonyms=["chebi"], uri_prefix="http://purl.obolibrary.org/obo/CHEBI_", uri_prefix_synonyms=["https://identifiers.org/chebi:"], ), ] ) self.assertEqual( "http://purl.obolibrary.org/obo/CHEBI_138488", converter.expand_or_standardize("CHEBI:138488"), ) self.assertEqual( "http://purl.obolibrary.org/obo/CHEBI_138488", converter.expand_or_standardize("chebi:138488"), ) self.assertEqual( "http://purl.obolibrary.org/obo/CHEBI_138488", converter.expand_or_standardize("http://purl.obolibrary.org/obo/CHEBI_138488"), ) self.assertEqual( "http://purl.obolibrary.org/obo/CHEBI_138488", converter.expand_or_standardize("https://identifiers.org/chebi:138488"), ) self.assertIsNone(converter.expand_or_standardize("missing:0000000")) with self.assertRaises(ExpansionError): converter.expand_or_standardize("missing:0000000", strict=True) self.assertEqual( "missing:0000000", converter.expand_or_standardize("missing:0000000", passthrough=True) ) self.assertIsNone(converter.expand_or_standardize("https://example.com/missing:0000000")) with self.assertRaises(ExpansionError): converter.expand_or_standardize("https://example.com/missing:0000000", strict=True) self.assertEqual( "https://example.com/missing:0000000", converter.expand_or_standardize( "https://example.com/missing:0000000", passthrough=True ), ) def test_compress_ambiguous(self) -> None: """Test compression of URI or CURIEs.""" converter = Converter.from_extended_prefix_map( [ Record( prefix="CHEBI", prefix_synonyms=["chebi"], uri_prefix="http://purl.obolibrary.org/obo/CHEBI_", uri_prefix_synonyms=["https://identifiers.org/chebi:"], ), ] ) self.assertEqual("CHEBI:138488", converter.compress_or_standardize("CHEBI:138488")) self.assertEqual("CHEBI:138488", converter.compress_or_standardize("chebi:138488")) self.assertEqual( "CHEBI:138488", converter.compress_or_standardize("http://purl.obolibrary.org/obo/CHEBI_138488"), ) self.assertEqual( "CHEBI:138488", converter.compress_or_standardize("https://identifiers.org/chebi:138488"), ) self.assertIsNone(converter.expand_or_standardize("missing:0000000")) with self.assertRaises(ExpansionError): converter.expand_or_standardize("missing:0000000", strict=True) self.assertEqual( "missing:0000000", converter.expand_or_standardize("missing:0000000", passthrough=True) ) self.assertIsNone(converter.expand_or_standardize("https://example.com/missing:0000000")) with self.assertRaises(ExpansionError): converter.expand_or_standardize("https://example.com/missing:0000000", strict=True) self.assertEqual( "https://example.com/missing:0000000", converter.expand_or_standardize( "https://example.com/missing:0000000", passthrough=True ), ) def test_standardize_identifier(self) -> None: """Test standardizing identifiers.""" class BananaStripperConverter(Converter): """A converter that removes bananas from LUIDs.""" # docstr-coverage:excused `overload` @overload def standardize_identifier( self, standard_prefix: str, identifier: str, strict: Literal[True] = ... ) -> str: ... # docstr-coverage:excused `overload` @overload def standardize_identifier( self, standard_prefix: str, identifier: str, strict: Literal[False] = ... ) -> str | None: ... def standardize_identifier( self, standard_prefix: str, identifier: str, strict: bool = False ) -> str | None: """Standardize the identifier by removing a banana and checking it is numeric.""" norm_identifier = identifier.removeprefix(f"{standard_prefix}:") # now, do some validation if not norm_identifier.isnumeric(): return None return norm_identifier converter = BananaStripperConverter( records=[ Record( prefix="CHEBI", prefix_synonyms=["chebi"], uri_prefix="http://purl.obolibrary.org/obo/CHEBI_", uri_prefix_synonyms=["https://identifiers.org/chebi:"], ), ] ) self.assertEqual(ReferenceTuple("CHEBI", "1234"), converter.parse_curie("CHEBI:1234")) self.assertEqual(ReferenceTuple("CHEBI", "1234"), converter.parse_curie("chebi:1234")) self.assertEqual(ReferenceTuple("CHEBI", "1234"), converter.parse_curie("CHEBI:CHEBI:1234")) self.assertEqual(ReferenceTuple("CHEBI", "1234"), converter.parse_curie("chebi:CHEBI:1234")) self.assertIsNone(converter.parse_curie("NOPE:NOPE:1234", strict=False)) self.assertIsNone(converter.parse_curie("CHEBI:nope", strict=False)) # does not solve the problem of synonyms in the banana, this is specific # to the current implementation in this test self.assertIsNone(converter.parse_curie("chebi:chebi:1234", strict=False)) with self.assertRaises(ValueError): converter.parse_curie("CHEBI:nope", strict=True) def test_add_prefix_synonym(self) -> None: """Test adding a prefix synonym.""" c = Converter() c.add_prefix("a", "https://example.org/a/") c.add_prefix("b", "https://example.org/b/") c.add_prefix_synonym("a", "x") self.assertEqual( Record(prefix="a", uri_prefix="https://example.org/a/", prefix_synonyms=["x"]), c.get_record("a"), ) with self.assertRaises(ValueError): c.add_prefix_synonym("a", "b") with self.assertRaises(KeyError): c.add_prefix_synonym("A", "y") def test_add_uri_prefix_synonym(self) -> None: """Test adding a prefix synonym.""" c = Converter() c.add_prefix("a", "https://example.org/a/") c.add_prefix("b", "https://example.org/b/") c.add_uri_prefix_synonym("a", "https://example.org/a2/") self.assertEqual( Record( prefix="a", uri_prefix="https://example.org/a/", uri_prefix_synonyms=["https://example.org/a2/"], ), c.get_record("a"), ) with self.assertRaises(ValueError): c.add_uri_prefix_synonym("a", "https://example.org/b/") with self.assertRaises(KeyError): c.add_uri_prefix_synonym("A", "y") class TestVersion(unittest.TestCase): """Trivially test a version.""" def test_version_type(self) -> None: """Test the version is a string. This is only meant to be an example test. """ version = get_version() self.assertIsInstance(version, str) class TestUtils(unittest.TestCase): """Test utility functions.""" def test_clean(self) -> None: """Test clean.""" prefix_map = { "b": "https://example.com/a/", "a": "https://example.com/a/", "c": "https://example.com/c/", } records = upgrade_prefix_map(prefix_map) self.assertEqual(2, len(records)) a_record, c_record = records self.assertEqual("a", a_record.prefix) self.assertEqual(["b"], a_record.prefix_synonyms) self.assertEqual("https://example.com/a/", a_record.uri_prefix) self.assertEqual([], a_record.uri_prefix_synonyms) self.assertEqual("c", c_record.prefix) self.assertEqual([], c_record.prefix_synonyms) self.assertEqual("https://example.com/c/", c_record.uri_prefix) self.assertEqual([], c_record.uri_prefix_synonyms) def test_parse_xsd(self) -> None: """Test parsing XSD.""" with self.assertRaises(KeyError): parse_xsd("doesn't matter", Reference(prefix="something", identifier="wrong")) for expected, s, datatype in [ (True, "true", v.xsd_boolean), (False, "false", v.xsd_boolean), (datetime.date(2026, 7, 31), "2026-07-31", v.xsd_date), (5, "5", v.xsd_integer), (5.0, "5", v.xsd_float), (5.1, "5.1", v.xsd_float), (AnyUrl("https://example.org"), "https://example.org/", v.xsd_uri), ]: with self.subTest(value=s): self.assertEqual(expected, parse_xsd(s, datatype)) biopragmatics-curies-aa8bd37/tests/test_database.py000066400000000000000000000267571525104130300226530ustar00rootroot00000000000000"""Tests for database adapters.""" from __future__ import annotations import unittest from curies import Prefix, Reference from curies.database import ( get_reference_list_sa_column, get_reference_sa_column, get_reference_sa_composite, ) prefix = Prefix("hero") id_1 = "1" id_2 = "2" id_3 = "3" id_4 = "4" id_5 = "5" name_1 = "Name 1" name_2 = "Name 2" name_3 = "Name 3" class TestDatabase(unittest.TestCase): """Tests for database adapters.""" def test_sqlalchemy(self) -> None: """Test SQLalchemy.""" from sqlalchemy import Column, Integer, String, create_engine from sqlalchemy.orm import DeclarativeBase, Session class Base(DeclarativeBase): """A base.""" class MyModel(Base): """A SQLAlchemy model that uses a reference.""" __tablename__ = "my_model" id = Column(Integer, primary_key=True) reference = get_reference_sa_column() name = Column(String) engine = create_engine("sqlite://") Base.metadata.create_all(engine) model_1 = MyModel(reference=Reference(prefix=prefix, identifier=id_1), name=name_1) model_2 = MyModel(reference=Reference(prefix=prefix, identifier=id_2), name=name_2) model_3 = MyModel(reference=Reference(prefix=prefix, identifier=id_3), name=name_3) with Session(engine) as session: session.add(model_1) session.add(model_2) session.add(model_3) session.commit() # Test querying with reconstitution with Session(engine) as session: result = ( session.query(MyModel) .filter(MyModel.reference == Reference(prefix=prefix, identifier=id_1)) .one() ) self.assertIsInstance(result.reference, Reference) self.assertEqual(prefix, result.reference.prefix) self.assertEqual(id_1, result.reference.identifier) self.assertEqual(name_1, result.name) def test_sqlalchemy_composite(self) -> None: """Test SQLAlchemy composite models.""" from sqlalchemy import Column, Integer, String, create_engine from sqlalchemy.orm import DeclarativeBase, Session class Base(DeclarativeBase): """A base.""" class MyModel(Base): """A model for testing composite references.""" __tablename__ = "my_model" id = Column(Integer, primary_key=True) reference_prefix = Column(String, nullable=False) reference_identifier = Column(String, nullable=False) name = Column(String, nullable=False) reference = get_reference_sa_composite(reference_prefix, reference_identifier) engine = create_engine("sqlite://") Base.metadata.create_all(engine) model_1 = MyModel(reference=Reference(prefix=prefix, identifier=id_1), name=name_1) model_2 = MyModel(reference=Reference(prefix=prefix, identifier=id_2), name=name_2) model_3 = MyModel(reference=Reference(prefix=prefix, identifier=id_3), name=name_3) with Session(engine) as session: session.add(model_1) session.add(model_2) session.add(model_3) session.commit() # Test querying with reconstitution with Session(engine) as session: result = ( session.query(MyModel) .filter(MyModel.reference == Reference(prefix=prefix, identifier=id_1)) .one() ) self.assertIsInstance(result.reference, Reference) self.assertEqual(prefix, result.reference.prefix) self.assertEqual(id_1, result.reference.identifier) self.assertEqual(name_1, result.name) def test_sqlmodel(self) -> None: """Test SQLModel.""" from sqlmodel import Field, Session, SQLModel, create_engine, select class Model(SQLModel, table=True): """A class with a reference.""" id: int | None = Field(default=None, primary_key=True) reference: Reference = Field(sa_column=get_reference_sa_column()) optional_reference: Reference | None = Field(sa_column=get_reference_sa_column()) listed_references: list[Reference] = Field( sa_column=get_reference_list_sa_column(), default_factory=list ) name: str model_1 = Model(reference=Reference(prefix=prefix, identifier=id_1), name=name_1) model_2 = Model(reference=Reference(prefix=prefix, identifier=id_2), name=name_2) model_3 = Model( reference=Reference(prefix=prefix, identifier=id_3), optional_reference=Reference(prefix=prefix, identifier=id_3), name=name_3, listed_references=[ Reference(prefix=prefix, identifier="l1"), Reference(prefix=prefix, identifier="l2"), ], ) engine = create_engine("sqlite://") SQLModel.metadata.create_all(engine) with Session(engine) as session: session.add(model_1) session.add(model_2) session.add(model_3) session.commit() # Test querying with reconstitution with Session(engine) as session: statement = select(Model).where(Model.name == name_2) result_1 = session.exec(statement).first() if result_1 is None: raise TypeError # this shouldn't be possible self.assertIsInstance(result_1.reference, Reference) self.assertEqual(prefix, result_1.reference.prefix) self.assertEqual(id_2, result_1.reference.identifier) self.assertEqual(name_2, result_1.name) self.assertEqual([], result_1.listed_references) # Test querying using a string on the reference with Session(engine) as session: statement = select(Model).where(Model.reference == f"{prefix}:{id_3}") result_4 = session.exec(statement).first() if result_4 is None: raise TypeError # this shouldn't be possible self.assertIsInstance(result_4.reference, Reference) self.assertEqual(prefix, result_4.reference.prefix) self.assertEqual(id_3, result_4.reference.identifier) self.assertEqual(name_3, result_4.name) self.assertIsNotNone(result_4.optional_reference) self.assertEqual( [Reference(prefix=prefix, identifier="l1"), Reference(prefix=prefix, identifier="l2")], result_4.listed_references, ) # Tests looking up a reference that's missing with Session(engine) as session: statement = select(Model).where( Model.reference == Reference(prefix="nope", identifier="nope") ) self.assertIsNone(session.exec(statement).one_or_none()) # Tests looking a reference that's there with Session(engine) as session: statement = select(Model).where( Model.reference == Reference(prefix=prefix, identifier=id_1) ) result_3 = session.exec(statement).first() if result_3 is None: raise TypeError # this shouldn't be possible self.assertIsInstance(result_3.reference, Reference) self.assertEqual(prefix, result_3.reference.prefix) self.assertEqual(id_1, result_3.reference.identifier) self.assertEqual(name_1, result_3.name) self.assertEqual([], result_3.listed_references) def test_sqlmodel_reference_list_default(self) -> None: """Test SQLModel with a reference list with a default factory.""" from sqlmodel import Field, Session, SQLModel, create_engine, select class ModelWithReferenceList(SQLModel, table=True): """A class with a reference.""" id: int | None = Field(default=None, primary_key=True) authors: list[Reference] = Field( sa_column=get_reference_list_sa_column(), default_factory=list ) model_1 = ModelWithReferenceList(id=1, authors=[Reference(prefix=prefix, identifier=id_1)]) model_2 = ModelWithReferenceList(id=2) engine = create_engine("sqlite://") SQLModel.metadata.create_all(engine) with Session(engine) as session: session.add_all([model_1, model_2]) session.commit() with Session(engine) as session: statement = select(ModelWithReferenceList).where(ModelWithReferenceList.id == 1) result_1 = session.exec(statement).first() if result_1 is None: self.fail() self.assertEqual([Reference(prefix=prefix, identifier=id_1)], result_1.authors) with Session(engine) as session: statement = select(ModelWithReferenceList).where(ModelWithReferenceList.id == 2) result_2 = session.exec(statement).first() if result_2 is None: self.fail() self.assertEqual([], result_2.authors) def test_sqlmodel_reference_list_no_default(self) -> None: """Test SQLModel with a reference list with no default factory.""" from sqlmodel import Field, Session, SQLModel, create_engine, select class ModelReferenceListNoDefault(SQLModel, table=True): """A class with a reference.""" id: int | None = Field(default=None, primary_key=True) authors: list[Reference] = Field(sa_column=get_reference_list_sa_column()) model_1 = ModelReferenceListNoDefault( id=1, authors=[Reference(prefix=prefix, identifier=id_1)] ) engine = create_engine("sqlite://") SQLModel.metadata.create_all(engine) with Session(engine) as session: session.add(model_1) session.commit() with Session(engine) as session: statement = select(ModelReferenceListNoDefault).where( ModelReferenceListNoDefault.id == 1 ) result_1 = session.exec(statement).first() if result_1 is None: self.fail() self.assertEqual([Reference(prefix=prefix, identifier=id_1)], result_1.authors) def test_sqlmodel_reference_list_optional(self) -> None: """Test SQLModel with optional reference list.""" from sqlmodel import Field, Session, SQLModel, create_engine, select class ModelOptionalReferenceList(SQLModel, table=True): """A class with a reference.""" id: int | None = Field(default=None, primary_key=True) authors: list[Reference] | None = Field(None, sa_column=get_reference_list_sa_column()) model_1 = ModelOptionalReferenceList( id=1, authors=[Reference(prefix=prefix, identifier=id_1)] ) model_2 = ModelOptionalReferenceList(id=2) engine = create_engine("sqlite://") SQLModel.metadata.create_all(engine) with Session(engine) as session: session.add_all([model_1, model_2]) session.commit() with Session(engine) as session: statement = select(ModelOptionalReferenceList).where(ModelOptionalReferenceList.id == 1) result_1 = session.exec(statement).first() if result_1 is None: self.fail() self.assertEqual([Reference(prefix=prefix, identifier=id_1)], result_1.authors) with Session(engine) as session: statement = select(ModelOptionalReferenceList).where(ModelOptionalReferenceList.id == 2) result_2 = session.exec(statement).first() if result_2 is None: self.fail() self.assertIsNone(result_2.authors) biopragmatics-curies-aa8bd37/tests/test_dataframe.py000066400000000000000000000067411525104130300230220ustar00rootroot00000000000000"""Test dataframe utilities.""" import typing import unittest import pandas as pd from curies import Converter from curies.dataframe import ( PrefixIndexMethod, filter_df_by_curies, filter_df_by_prefixes, get_df_curies_index, get_df_prefixes_index, get_df_unique_prefixes, get_filter_df_by_prefixes_index, ) CONVERTER = Converter.from_prefix_map( { "a": "https://example.org/a/", "b": "https://example.org/b/", "c": "https://example.org/c/", } ) class TestDataframe(unittest.TestCase): """A test case for dataframe utilities.""" def test_get_prefix_index(self) -> None: """Test getting a prefix index.""" column = "curie" a_curies = [f"a:{i}" for i in range(5)] b_curies = [f"b:{i}" for i in range(5)] c_curies = [f"c:{i}" for i in range(5)] * 2 curies = [*a_curies, *b_curies, *c_curies] rows = [(curie,) for curie in curies] df = pd.DataFrame(rows, columns=[column]) with self.assertRaises(ValueError): get_filter_df_by_prefixes_index(df, prefixes="a", converter=CONVERTER) for method in typing.get_args(PrefixIndexMethod): with self.subTest(method=method): idx = get_filter_df_by_prefixes_index( df, column=column, prefixes="a", method=method, converter=CONVERTER ) self.assertEqual([0, 1, 2, 3, 4], _rr(idx)) idx = get_filter_df_by_prefixes_index( df[column], prefixes="a", method=method, converter=CONVERTER ) self.assertEqual([0, 1, 2, 3, 4], _rr(idx)) idx = get_filter_df_by_prefixes_index( df, column=column, prefixes=["a", "b"], method=method, converter=CONVERTER ) self.assertEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], _rr(idx)) df_a = filter_df_by_prefixes(df, column=column, prefixes="a") self.assertEqual(set(a_curies), set(df_a[column])) df_ab = filter_df_by_prefixes(df, column=column, prefixes=["a", "b"]) self.assertEqual({*a_curies, *b_curies}, set(df_ab[column])) df_a1 = filter_df_by_curies(df, column=column, curies="a:1") self.assertEqual({"a:1"}, set(df_a1[column])) df_a123 = filter_df_by_curies(df, column=column, curies=["a:1", "a:2", "b:1"]) self.assertEqual({"a:1", "a:2", "b:1"}, set(df_a123[column])) prefixes_index = { "a": [0, 1, 2, 3, 4], "b": [5, 6, 7, 8, 9], "c": [10, 11, 12, 13, 14, 15, 16, 17, 18, 19], } self.assertEqual(prefixes_index, get_df_prefixes_index(df, column=column)) self.assertEqual(prefixes_index, get_df_prefixes_index(df[column])) for curies_index in [ get_df_curies_index(df, column=column), get_df_curies_index(df[column]), ]: self.assertNotIn("a", curies_index) self.assertNotIn("b", curies_index) self.assertNotIn("c", curies_index) self.assertIn("a:0", curies_index) self.assertEqual([0], curies_index["a:0"]) self.assertEqual([10, 15], curies_index["c:0"]) self.assertEqual(set("abc"), get_df_unique_prefixes(df, column=column)) self.assertEqual(set("abc"), get_df_unique_prefixes(df[column])) def _rr(series: "pd.Series[bool]") -> list[int]: return [index for index, value in enumerate(series) if value] biopragmatics-curies-aa8bd37/tests/test_discovery.py000066400000000000000000000060041525104130300230750ustar00rootroot00000000000000"""Test discovering a prefix map from a list of URIs.""" import unittest from typing import ClassVar import rdflib from curies import Converter, Record from curies.discovery import discover, discover_from_rdf from tests.constants import SLOW class TestDiscovery(unittest.TestCase): """Test discovery of URI prefixes.""" converter: ClassVar[Converter] @classmethod def setUpClass(cls) -> None: """Set up the test case with a dummy converter.""" cls.converter = Converter( [ Record(prefix="GO", uri_prefix="http://purl.obolibrary.org/obo/GO_"), Record(prefix="rdfs", uri_prefix=str(rdflib.RDFS._NS)), ] ) def test_simple(self) -> None: """Test a simple case of discovering URI prefixes.""" uris = [f"http://ran.dom/{i:03}" for i in range(30)] uris.append("http://purl.obolibrary.org/obo/GO_0001234") converter = discover(uris, cutoff=3, converter=self.converter) self.assertEqual([Record(prefix="ns1", uri_prefix="http://ran.dom/")], converter.records) self.assertEqual("ns1:001", converter.compress("http://ran.dom/001")) self.assertIsNone( converter.compress("http://purl.obolibrary.org/obo/GO_0001234"), msg="discovered converter should not inherit reference converter's definitions", ) converter = discover(uris, cutoff=50, converter=self.converter) self.assertEqual([], converter.records) self.assertIsNone( converter.compress("http://ran.dom/001"), msg="cutoff was high, so discovered converter should not detect `http://ran.dom/`", ) def test_rdflib(self) -> None: """Test discovery in RDFlib.""" graph = rdflib.Graph() for i in range(30): graph.add( ( rdflib.URIRef(f"http://ran.dom/{i:03}"), rdflib.RDFS.subClassOf, rdflib.URIRef(f"http://ran.dom/{i + 1:03}"), ) ) graph.add( ( rdflib.URIRef(f"http://ran.dom/{i:03}"), rdflib.RDFS.label, rdflib.Literal(f"Node {i}"), ) ) converter = discover_from_rdf(graph, converter=self.converter) self.assertEqual([Record(prefix="ns1", uri_prefix="http://ran.dom/")], converter.records) self.assertEqual("ns1:001", converter.compress("http://ran.dom/001")) self.assertIsNone( converter.compress("http://purl.obolibrary.org/obo/GO_0001234"), msg="discovered converter should not inherit reference converter's definitions", ) @SLOW def test_remote(self) -> None: """Test parsing AEON.""" converter = discover_from_rdf( graph="https://raw.githubusercontent.com/tibonto/aeon/main/aeon.owl", format="xml", ) self.assertIn("http://purl.obolibrary.org/obo/AEON_", converter.reverse_prefix_map) biopragmatics-curies-aa8bd37/tests/test_federated_sparql.py000066400000000000000000000121611525104130300243740ustar00rootroot00000000000000"""Tests federated SPARQL queries with a locally deployed triple store.""" import itertools as itt import time import unittest from multiprocessing import Process from typing import ClassVar import fastapi import uvicorn from curies import Converter from curies.mapping_service import get_fastapi_mapping_app from curies.mapping_service.utils import ( get_sparql_record_so_tuples, get_sparql_records, require_service, sparql_service_available, ) from tests.test_mapping_service import PREFIX_MAP BLAZEGRAPH_ENDPOINT = "http://localhost:9999/blazegraph/namespace/kb/sparql" BLAZEGRAPH_JAR_URL = ( "https://github.com/blazegraph/database/releases/download/BLAZEGRAPH_2_1_6_RC/blazegraph.jar" ) SPARQL_VALUES_FMT = """\ PREFIX owl: SELECT DISTINCT ?s ?o WHERE {{ SERVICE <{mapping_service}> {{ VALUES ?s {{ }} ?s owl:sameAs ?o }} }} """.rstrip() SPARQL_VALUES_FMT_2 = """\ PREFIX owl: SELECT DISTINCT ?s ?o WHERE {{ VALUES ?s {{ }} SERVICE <{mapping_service}> {{ ?s owl:sameAs ?o }} }} """.rstrip() SPARQL_VALUES_FMT_3 = """\ PREFIX owl: SELECT DISTINCT ?s ?o WHERE {{ SERVICE <{mapping_service}> {{ ?s owl:sameAs ?o }} VALUES ?s {{ }} }} """.rstrip() SPARQL_SIMPLE_FMT = """\ PREFIX owl: SELECT DISTINCT ?s ?o WHERE {{ SERVICE <{mapping_service}> {{ owl:sameAs ?o . ?s owl:sameAs ?o . }} }} """.rstrip() SPARQL_SIMPLE_FMT_2 = """\ PREFIX owl: SELECT DISTINCT ?s ?o WHERE {{ SERVICE <{mapping_service}> {{ ?s owl:sameAs ?o . owl:sameAs ?o . }} }} """.rstrip() # TODO test SPARQL_SIMPLE_FMT_3 = """\ PREFIX owl: SELECT DISTINCT ?s ?o WHERE {{ owl:sameAs ?o . SERVICE <{mapping_service}> {{ ?s owl:sameAs ?o . }} }} """.rstrip() # TODO test SPARQL_SIMPLE_FMT_4 = """\ PREFIX owl: SELECT DISTINCT ?s ?o WHERE {{ SERVICE <{mapping_service}> {{ ?s owl:sameAs ?o . }} owl:sameAs ?o . }} """.rstrip() class FederationMixin(unittest.TestCase): """A shared mixin for testing.""" def assert_service_works(self, endpoint: str) -> None: """Assert that a service is able to accept a simple SPARQL query.""" self.assertTrue(sparql_service_available(endpoint)) def _get_app() -> fastapi.FastAPI: converter = Converter.from_priority_prefix_map(PREFIX_MAP) app = get_fastapi_mapping_app(converter) return app @require_service(BLAZEGRAPH_ENDPOINT, "Blazegraph") class TestFederatedSparql(FederationMixin): """Test the identifier mapping service.""" endpoint: ClassVar[str] = BLAZEGRAPH_ENDPOINT mimetypes: ClassVar[list[str]] = [ "application/sparql-results+json", "application/sparql-results+xml", "text/csv", # for some reason, Blazegraph wants this instead of application/sparql-results+csv ] query_formats: ClassVar[list[str]] = [ SPARQL_VALUES_FMT, SPARQL_VALUES_FMT_2, SPARQL_VALUES_FMT_3, SPARQL_SIMPLE_FMT, SPARQL_SIMPLE_FMT_2, ] host: ClassVar[str] = "localhost" port: ClassVar[int] = 8000 mapping_service_process: Process def setUp(self) -> None: """Set up the test case.""" # Start the curies mapping service SPARQL endpoint self.mapping_service_process = Process( target=uvicorn.run, # uvicorn.run accepts a zero-argument callable that returns an app args=(_get_app,), kwargs={"host": self.host, "port": self.port, "log_level": "info"}, daemon=True, ) self.mapping_service_process.start() time.sleep(5) self.mapping_service = f"http://{self.host}:{self.port}/sparql" self.queries = [ query_format.format(mapping_service=self.mapping_service) for query_format in self.query_formats ] self.assert_service_works(self.mapping_service) def tearDown(self) -> None: """Tear down the testing case.""" self.mapping_service_process.kill() def test_federated_local(self) -> None: """Test sending a federated query to a local mapping service from a local service.""" for mimetype, sparql in itt.product(self.mimetypes, self.queries): with self.subTest(mimetype=mimetype, sparql=sparql): records = get_sparql_records(self.endpoint, sparql, accept=mimetype) self.assertIn( ( "http://purl.obolibrary.org/obo/CHEBI_24867", "http://identifiers.org/chebi/24867", ), get_sparql_record_so_tuples(records), ) biopragmatics-curies-aa8bd37/tests/test_io.py000066400000000000000000000075171525104130300215070ustar00rootroot00000000000000"""Test writing I/O.""" import json import unittest from collections.abc import Iterable from pathlib import Path from tempfile import TemporaryDirectory from typing import cast import rdflib import curies from curies import Converter CHEBI_URI_PREFIX = "http://purl.obolibrary.org/obo/CHEBI_" class TestIO(unittest.TestCase): """Test I/O.""" def setUp(self) -> None: """Set up the test case.""" self.prefix = "CHEBI" self.uri_prefix = CHEBI_URI_PREFIX self.prefix_synonym = "p" self.uri_prefix_synonym = "u" self.pattern = "^\\d{7}$" self.converter = Converter.from_extended_prefix_map( [ { "prefix": self.prefix, "prefix_synonyms": [self.prefix_synonym], "uri_prefix": self.uri_prefix, "uri_prefix_synonyms": [self.uri_prefix_synonym], "pattern": self.pattern, }, ] ) def test_write_epm(self) -> None: """Test writing and reading an extended prefix map.""" with TemporaryDirectory() as d: path = Path(d).joinpath("test.json") curies.write_extended_prefix_map(self.converter, path) nc = curies.load_extended_prefix_map(path) self.assertEqual(self.converter.records, nc.records) self.assertEqual({self.prefix: self.pattern}, nc.pattern_map) def test_write_jsonld_with_bimap(self) -> None: """Test writing and reading a prefix map via JSON-LD.""" with TemporaryDirectory() as d: path = Path(d).joinpath("test.json") curies.write_jsonld_context(self.converter, path.as_posix()) nc = curies.load_jsonld_context(path) self.assertEqual({self.prefix: self.uri_prefix}, nc.prefix_map) self.assertEqual( {self.uri_prefix: self.prefix}, nc.reverse_prefix_map, msg="the prefix synonym should not survive round trip", ) self.assertEqual({self.prefix: self.uri_prefix}, nc.bimap) def test_write_jsonld_with_synonyms(self) -> None: """Test writing a JSON-LD with synonyms.""" # note: we don't test loading since loading a JSON-LD with synonyms is undefined for expand in [True, False]: with self.subTest(expand=expand): with TemporaryDirectory() as d: path = Path(d).joinpath("test.json") curies.write_jsonld_context(self.converter, path, include_synonyms=True) data = json.loads(path.read_text())["@context"] self.assertEqual({self.prefix, self.prefix_synonym}, set(data)) def test_shacl(self) -> None: """Test round-tripping SHACL.""" with TemporaryDirectory() as d: path = Path(d).joinpath("test.ttl") curies.write_shacl(self.converter, path) nc = curies.load_shacl(path) self.assertEqual(self.converter.bimap, nc.bimap) self.assertEqual({self.prefix: self.pattern}, nc.pattern_map) def test_shacl_with_synonyms(self) -> None: """Test writing SHACL with synonyms.""" # note: we don't test loading since loading SHACL with synonyms is undefined with TemporaryDirectory() as d: path = Path(d).joinpath("test.ttl") curies.write_shacl(self.converter, path, include_synonyms=True) graph = rdflib.Graph() graph.parse(location=path.as_posix(), format="turtle") query = """\ SELECT ?prefix WHERE { ?bnode sh:declare ?declaration . ?declaration sh:prefix ?prefix . } """ results = cast(Iterable[tuple[str]], graph.query(query)) self.assertEqual({self.prefix, self.prefix_synonym}, {str(prefix) for (prefix,) in results}) biopragmatics-curies-aa8bd37/tests/test_mapping_service.py000066400000000000000000000352071525104130300242500ustar00rootroot00000000000000"""Tests for the identifier mapping service.""" import unittest from urllib.parse import quote import httpx2 import werkzeug.test from fastapi.testclient import TestClient from flask.testing import FlaskClient from rdflib import OWL, SKOS from rdflib.query import Result from curies import Converter from curies.mapping_service import ( MappingServiceGraph, MappingServiceSPARQLProcessor, get_fastapi_mapping_app, get_flask_mapping_app, ) from curies.mapping_service.api import _prepare_predicates from curies.mapping_service.utils import ( CONTENT_TYPE_SYNONYMS, CONTENT_TYPE_TO_HANDLER, handle_header, sparql_service_available, ) from tests.constants import SLOW VALID_CONTENT_TYPES = { *CONTENT_TYPE_TO_HANDLER, "", "*/*", *CONTENT_TYPE_SYNONYMS, } PREFIX_MAP = { "CHEBI": [ "https://www.ebi.ac.uk/chebi/searchId.do?chebiId=", "http://identifiers.org/chebi/", "http://purl.obolibrary.org/obo/CHEBI_", ], "GO": ["http://purl.obolibrary.org/obo/GO_"], "OBO": ["http://purl.obolibrary.org/obo/"], } SPARQL_SIMPLE = """\ SELECT DISTINCT ?s ?o WHERE { VALUES ?s { } ?s owl:sameAs ?o } """.rstrip() SPARQL_SIMPLE_BACKWARDS = """\ SELECT DISTINCT ?s ?o WHERE { VALUES ?o { } ?s owl:sameAs ?o } """.rstrip() #: This represents a SPARQL query that happens when a service generates it SPARQL_FROM_SERVICE = """\ SELECT REDUCED * WHERE { ?s owl:sameAs ?o . } VALUES (?s) { () () } """ SPARQL_FULLY_SPECIFIED_NOPE = """\ SELECT * WHERE { owl:sameAs } """ EXPECTED = { ( "http://purl.obolibrary.org/obo/CHEBI_1", "http://purl.obolibrary.org/obo/CHEBI_1", ), ("http://purl.obolibrary.org/obo/CHEBI_1", "http://identifiers.org/chebi/1"), ( "http://purl.obolibrary.org/obo/CHEBI_1", "https://www.ebi.ac.uk/chebi/searchId.do?chebiId=1", ), ( "http://purl.obolibrary.org/obo/CHEBI_2", "http://purl.obolibrary.org/obo/CHEBI_2", ), ("http://purl.obolibrary.org/obo/CHEBI_2", "http://identifiers.org/chebi/2"), ( "http://purl.obolibrary.org/obo/CHEBI_2", "https://www.ebi.ac.uk/chebi/searchId.do?chebiId=2", ), } def _stm(rows: Result) -> set[tuple[str, str]]: return {(str(row.s), str(row.o)) for row in rows} # type: ignore class TestMappingService(unittest.TestCase): """Test the identifier mapping service.""" def setUp(self) -> None: """Set up the converter.""" self.converter = Converter.from_priority_prefix_map(PREFIX_MAP) self.graph = MappingServiceGraph(converter=self.converter) self.processor = MappingServiceSPARQLProcessor(self.graph) # type:ignore[no-untyped-call] def _query(self, sparql: str) -> Result: return self.graph.query(sparql, processor=self.processor) def test_parse_header(self) -> None: """Test parsing a rather complex header.""" example_header = ( "application/sparql-results+xml;q=0.8," "application/xml;q=0.8," "application/x-binary-rdf-results-table," "application/sparql-results+json;q=0.8," "application/json;q=0.8," "text/csv;q=0.8," "text/tab-separated-values;q=0.8" ) content_type = handle_header(example_header) self.assertEqual("application/sparql-results+xml", content_type) def test_prepare_predicates(self) -> None: """Test preparation of predicates.""" self.assertEqual({OWL.sameAs}, _prepare_predicates()) self.assertEqual({OWL.sameAs}, _prepare_predicates(OWL.sameAs)) self.assertEqual( {OWL.sameAs, SKOS.exactMatch}, _prepare_predicates({OWL.sameAs, SKOS.exactMatch}) ) def test_errors(self) -> None: """Test errors.""" for sparql in [ # errors because of unbound subject "SELECT ?s ?o WHERE { ?s owl:sameAs ?o }", # errors because of bad predicate "SELECT ?o WHERE { rdfs:seeAlso ?o }", "SELECT ?s WHERE { ?s rdfs:seeAlso }", # errors because of unknown URI "SELECT ?o WHERE { owl:sameAs ?o }", "SELECT ?s WHERE { ?s owl:sameAs }", # errors because predicate is given ( "SELECT * WHERE { " "owl:sameAs }" ), ]: with self.subTest(sparql=sparql): self.assertEqual([], list(self._query(sparql))) def test_sparql(self) -> None: """Test a sparql query on the graph.""" rows = _stm(self._query(SPARQL_SIMPLE)) self.assertNotEqual(0, len(rows), msg="No results were returned") self.assertEqual(EXPECTED, rows) def test_ask(self) -> None: """Test fully specified mapping triples.""" qq = [ ( True, "ASK WHERE { owl:sameAs }", ), ( False, "ASK WHERE { owl:sameAs }", ), ] for answer, sparql in qq: with self.subTest(sparql=sparql): self.assertEqual(answer, self._query(sparql).askAnswer) def test_sparql_backwards(self) -> None: """Test a sparql query on the graph.""" rows = _stm(self._query(SPARQL_SIMPLE_BACKWARDS)) self.assertNotEqual(0, len(rows), msg="No results were returned") expected = {(o, s) for s, o in EXPECTED} self.assertEqual(expected, rows) def test_service_sparql(self) -> None: """Test the SPARQL that gets sent when using this as a service.""" rows = _stm(self._query(SPARQL_FROM_SERVICE)) self.assertNotEqual(0, len(rows), msg="No results were returned") self.assertEqual(EXPECTED, rows) def test_fully_specified_nope(self) -> None: """Test the SPARQL that gets sent when using this as a service.""" rows = list(self._query(SPARQL_FULLY_SPECIFIED_NOPE)) self.assertEqual(0, len(rows), msg="No results were returned") def test_missing(self) -> None: """Test a sparql query on the graph where the URIs can't be parsed.""" sparql = """\ SELECT ?s ?o WHERE { VALUES ?s { } ?s owl:sameAs ?o } """ self.assertEqual([], list(self._query(sparql))) def test_safe_expand(self) -> None: """Test that expansion to invalid prefixes doesn't happen.""" ppm = { "CHEBI": [ "http://purl.obolibrary.org/obo/CHEBI_", "http://identifiers.org/chebi/", "http://identifiers.org/chebi/nope nope:", ], } converter = Converter.from_priority_prefix_map(ppm) graph = MappingServiceGraph(converter=converter) self.assertEqual( {"http://purl.obolibrary.org/obo/CHEBI_1", "http://identifiers.org/chebi/1"}, set(map(str, graph._expand_pair_all("http://purl.obolibrary.org/obo/CHEBI_1"))), ) class ConverterMixin(unittest.TestCase): """A mixin that has a converter.""" def setUp(self) -> None: """Set up the test case with a converter.""" super().setUp() self.converter = Converter.from_priority_prefix_map(PREFIX_MAP) def assert_mimetype( self, res: httpx2.Response | werkzeug.test.TestResponse, content_type: str ) -> None: """Assert the correct MIMETYPE.""" content_type = handle_header(content_type) mimetype = getattr(res, "mimetype", None) if hasattr(res, "mimetype"): # this is from Flask self.assertEqual(content_type, mimetype) else: # this is from FastAPI actual_content_type = res.headers.get("content-type") if actual_content_type is None: self.fail("content type was none") self.assertEqual(content_type, actual_content_type.split(";")[0].strip()) def assert_parsed( self, res: httpx2.Response | werkzeug.test.TestResponse, content_type: str ) -> None: """Test the result has the expected output.""" content_type = handle_header(content_type) parse_func = CONTENT_TYPE_TO_HANDLER[content_type] records = parse_func(res.text) pairs = {(record["s"], record["o"]) for record in records} self.assertEqual(EXPECTED, pairs) def assert_get_sparql_results(self, client: TestClient | FlaskClient, sparql: str) -> None: """Test a sparql query returns expected values.""" for content_type in sorted(VALID_CONTENT_TYPES): with self.subTest(content_type=content_type): res = client.get(f"/sparql?query={quote(sparql)}", headers={"accept": content_type}) self.assertEqual(200, res.status_code, msg=f"Response: {res}\n\n{res.text}") self.assert_mimetype(res, content_type) self.assert_parsed(res, content_type) def assert_post_sparql_results(self, client: TestClient | FlaskClient, sparql: str) -> None: """Test a sparql query returns expected values.""" for content_type in sorted(VALID_CONTENT_TYPES): with self.subTest(content_type=content_type): res = client.post( # note that we're using "data" and not JSON since this service # is posting "form data" and not a JSON payload "/sparql", data={"query": sparql}, headers={"accept": content_type}, ) self.assertEqual( 200, res.status_code, msg=f"Response: {res}", ) self.assert_mimetype(res, content_type) self.assert_parsed(res, content_type) class TestFlaskMappingWeb(ConverterMixin): """Test the Flask-based mapping service.""" def setUp(self) -> None: """Set up the test case with a converter and app.""" super().setUp() self.app = get_flask_mapping_app(self.converter) def test_get_missing_query(self) -> None: """Test error on missing query parameter.""" with self.app.test_client() as client: for content_type in sorted(VALID_CONTENT_TYPES): with self.subTest(content_type=content_type): res = client.get("/sparql", headers={"accept": content_type}) self.assertEqual(400, res.status_code, msg=f"Response: {res}") def test_post_missing_query(self) -> None: """Test error on missing query parameter.""" with self.app.test_client() as client: for content_type in sorted(VALID_CONTENT_TYPES): with self.subTest(content_type=content_type): res = client.post("/sparql", headers={"accept": content_type}) self.assertEqual(400, res.status_code, msg=f"Response: {res}") def test_get_query(self) -> None: """Test querying the app with GET.""" with self.app.test_client() as client: self.assert_get_sparql_results(client, SPARQL_SIMPLE) def test_post_query(self) -> None: """Test querying the app with POST.""" with self.app.test_client() as client: self.assert_post_sparql_results(client, SPARQL_SIMPLE) def test_get_service_query(self) -> None: """Test sparql generated by a service (that has values outside of where clause) with GET.""" with self.app.test_client() as client: self.assert_get_sparql_results(client, SPARQL_FROM_SERVICE) def test_post_service_query(self) -> None: """Test sparql generated by a service (that has values outside of where clause) with POST.""" with self.app.test_client() as client: self.assert_post_sparql_results(client, SPARQL_FROM_SERVICE) class TestFastAPIMappingApp(ConverterMixin): """Test the FastAPI-based mapping service.""" def setUp(self) -> None: """Set up the test case with a converter, blueprint, and app.""" super().setUp() self.app = get_fastapi_mapping_app(self.converter) self.client = TestClient(self.app) def test_get_missing_query(self) -> None: """Test error on missing query parameter.""" for content_type in sorted(VALID_CONTENT_TYPES): with self.subTest(content_type=content_type): res = self.client.get("/sparql", headers={"accept": content_type}) self.assertEqual(422, res.status_code, msg=f"Response: {res}") def test_post_missing_query(self) -> None: """Test error on missing query parameter.""" for content_type in sorted(VALID_CONTENT_TYPES): with self.subTest(content_type=content_type): res = self.client.post("/sparql", headers={"accept": content_type}) self.assertEqual(422, res.status_code, msg=f"Response: {res}") def test_get_query(self) -> None: """Test querying the app with GET.""" self.assert_get_sparql_results(self.client, SPARQL_SIMPLE) def test_post_query(self) -> None: """Test querying the app with POST.""" self.assert_post_sparql_results(self.client, SPARQL_SIMPLE) def test_get_service_query(self) -> None: """Test sparql generated by a service (that has values outside of where clause) with GET.""" self.assert_get_sparql_results(self.client, SPARQL_FROM_SERVICE) def test_post_service_query(self) -> None: """Test sparql generated by a service (that has values outside of where clause) with POST.""" self.assert_post_sparql_results(self.client, SPARQL_FROM_SERVICE) class TestUtils(unittest.TestCase): """Test utilities.""" @unittest.skip(reason="Wikidata query service is down") @SLOW def test_availability(self) -> None: """Test sparql service availability check.""" self.assertTrue( sparql_service_available("https://query.wikidata.org/bigdata/namespace/wdq/sparql") ) self.assertFalse(sparql_service_available("https://example.org")) biopragmatics-curies-aa8bd37/tests/test_mixins.py000066400000000000000000000051501525104130300223760ustar00rootroot00000000000000"""Test mixins.""" import unittest from typing import Self from pydantic import BaseModel import curies from curies import Converter, Reference from curies.mixins import ( SemanticallyProcessable, SemanticallyStandardizable, process_many, standardize_many, ) class TestMixins(unittest.TestCase): """Test mixins.""" def test_semantically_processable(self) -> None: """Test processing.""" class Processed(BaseModel): """A processed model, with a reference.""" reference: Reference class Raw(BaseModel, SemanticallyProcessable[Processed]): """A raw model, with a URI.""" uri: str def process(self, converter: Converter) -> Processed: """Process the raw model.""" return Processed(reference=converter.parse(self.uri, strict=True).to_pydantic()) converter = Converter.from_prefix_map({"GO": "http://purl.obolibrary.org/obo/GO_"}) initial = Raw(uri="http://purl.obolibrary.org/obo/GO_1234567") actual = initial.process(converter) self.assertIsInstance(actual, Processed) expected = Processed(reference=Reference(prefix="GO", identifier="1234567")) self.assertEqual(expected, actual) self.assertEqual([expected], process_many([initial], converter)) # check none handling self.assertIsNone(process_many(None, converter)) def test_standardizable(self) -> None: """Test standardizable.""" class HoldsReference(BaseModel, SemanticallyStandardizable): """A test class with a reference.""" reference: Reference def standardize(self, converter: Converter) -> Self: """Standardize the reference in the object.""" return self.model_copy( update={ "reference": converter.standardize_reference(self.reference, strict=True), } ) converter = Converter( [ curies.Record( prefix="TEST", prefix_synonyms=["test"], uri_prefix="https://example.org/" ) ] ) initial = HoldsReference(reference=Reference(prefix="test", identifier="1234567")) actual = initial.standardize(converter) expected = HoldsReference(reference=Reference(prefix="TEST", identifier="1234567")) self.assertEqual(expected, actual) self.assertEqual([expected], standardize_many([initial], converter)) # check none handling self.assertIsNone(standardize_many(None, converter)) biopragmatics-curies-aa8bd37/tests/test_preprocessing.py000066400000000000000000000211461525104130300237550ustar00rootroot00000000000000"""Tests for preprocessing converter.""" # coverage erase && coverage run -p -m pytest tests/test_wrapped.py --durations=20 && coverage combine && coverage html && open htmlcov/index.html import tempfile import unittest from pathlib import Path from typing import ClassVar from curies import Converter, ReferenceTuple from curies.preprocessing import ( BlocklistError, PostprocessingRewrites, PreprocessingBlocklists, PreprocessingConverter, PreprocessingRewrites, PreprocessingRules, ) EX1_RT = ReferenceTuple("GO", "1234567") EX1_URI = "http://purl.obolibrary.org/obo/GO_1234567" EX1_CURIE = "GO:1234567" DECOY_1_CURIE = "NOPE:NOPE" DECOY_1_URI = "https://example.org/NOPE/NOPE" class TestWrapped(unittest.TestCase): """Tests for preprocessing converter.""" rules: ClassVar[PreprocessingRules] inner_converter: ClassVar[Converter] converter: ClassVar[PreprocessingConverter] temporary_directory: ClassVar[tempfile.TemporaryDirectory[str]] directory: ClassVar[Path] rules_path: ClassVar[Path] @classmethod def setUpClass(cls) -> None: """Set up the test case.""" cls.rules = PreprocessingRules( rewrites=PreprocessingRewrites( full={ "is_a": "rdf:type", "http://creativecommons.org/licenses/by/3.0/": "spdx:CC-BY-3.0", }, prefix={ "OMIM:PS": "omim.ps:", "omim:PS": "omim.ps:", }, resource_prefix={ "clo": { "j": "NCIT:", }, }, resource_full={ "clo": { "nopeforever": "NCIT:5678", }, }, ), blocklists=PreprocessingBlocklists( full=["rdf:NOPE"], resource_prefix={ "chebi": [ "pubmed:" ] # this means that only throw away pubmed references in ChEBI }, resource_full={ "chebi": ["omim:1356"], # in case we just hate this CURIE/URI/string }, ), postprocessing=PostprocessingRewrites( suffix={ "emedicine": ["-overview"], } ), ) cls.inner_converter = Converter.from_prefix_map( { "GO": "http://purl.obolibrary.org/obo/GO_", "NCIT": "http://purl.obolibrary.org/obo/NCIT_", "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#", "rdfs": "http://www.w3.org/2000/01/rdf-schema#", "omim": "https://omim.org/MIM:", "omim.ps": "https://omim.org/phenotypicSeries/PS", "pubmed": "http://rdf.ncbi.nlm.nih.gov/pubchem/reference/", "spdx": "https://spdx.org/licenses/", "emedicine": "http://emedicine.medscape.com/article/", } ) cls.temporary_directory = tempfile.TemporaryDirectory() cls.directory = Path(cls.temporary_directory.name) # write the rules just so we can test loading from a file cls.rules_path = cls.directory.joinpath("rules.json") cls.rules_path.write_text(cls.rules.model_dump_json(indent=2, exclude_unset=True)) cls.converter = PreprocessingConverter.from_converter( converter=cls.inner_converter, rules=cls.rules_path ) @classmethod def tearDownClass(cls) -> None: """Clean up the class.""" cls.temporary_directory.cleanup() def test_lint(self) -> None: """Run the linting code, just to make sure it works.""" self.rules.lint_file(self.rules_path) def test_unprocessed(self) -> None: """Tests that should be the same for both converters.""" for converter in (self.inner_converter, self.converter): self.assertEqual(EX1_CURIE, converter.compress(EX1_URI)) self.assertEqual(EX1_URI, converter.expand(EX1_CURIE)) self.assertEqual(EX1_RT, converter.parse(EX1_URI)) self.assertEqual(EX1_RT, converter.parse(EX1_CURIE)) self.assertEqual(EX1_RT, converter.parse_uri(EX1_URI)) self.assertEqual(EX1_RT, converter.parse_curie(EX1_CURIE)) self.assertIsNone(converter.compress(DECOY_1_URI)) self.assertIsNone(converter.expand(DECOY_1_CURIE)) self.assertIsNone(converter.parse_curie(DECOY_1_CURIE)) self.assertIsNone(converter.parse_uri(DECOY_1_URI)) self.assertIsNone(converter.parse(DECOY_1_URI)) self.assertIsNone(converter.parse(DECOY_1_CURIE)) def test_global_full_rewrite(self) -> None: """Test global full string rewrite.""" self.assertEqual(ReferenceTuple("rdf", "type"), self.converter.parse("is_a")) self.assertEqual(ReferenceTuple("rdf", "type"), self.converter.parse_curie("is_a")) self.assertEqual( ReferenceTuple("spdx", "CC-BY-3.0"), self.converter.parse_uri("http://creativecommons.org/licenses/by/3.0/"), ) def test_global_prefix_rewrite(self) -> None: """Test global prefix rewrite.""" self.assertEqual( ReferenceTuple("omim.ps", "1234"), self.converter.parse_curie("OMIM:PS1234") ) # test when there's a related rewrite rule, but not used self.assertEqual(ReferenceTuple("omim", "1234"), self.converter.parse_curie("omim:1234")) def test_resource_full_rewrite(self) -> None: """Test global full string rewrite.""" self.assertIsNone(self.converter.parse("nopeforever")) with self.assertRaises(ValueError): self.converter.parse_curie("nopeforever") self.assertEqual( ReferenceTuple("NCIT", "5678"), self.converter.parse_curie("nopeforever", context="clo"), ) def test_resource_prefix_rewrite(self) -> None: """Test resource-specific prefix rewrite.""" self.assertEqual( ReferenceTuple("NCIT", "1234"), self.converter.parse("j1234", context="clo"), ) # when we have rewrite rules for that ontology, but none apply self.assertIsNone(self.converter.parse("xyz", context="clo")) with self.assertRaises(ValueError): self.assertIsNone(self.converter.parse_curie("j1234")) with self.assertRaises(ValueError): self.assertIsNone(self.converter.parse_curie("j1234", context="chebi")) def test_resource_specific_blocklist(self) -> None: """Test resource-specific blocklist.""" self.assertEqual( ReferenceTuple("pubmed", "1234"), self.converter.parse_curie("pubmed:1234"), ) self.assertEqual( ReferenceTuple("pubmed", "1234"), self.converter.parse_curie("pubmed:1234", context="doid"), ) with self.assertRaises(BlocklistError): self.converter.parse_curie("pubmed:1234", context="chebi") self.assertIsNone( self.converter.parse_curie("pubmed:1234", context="chebi", block_action="pass") ) self.converter.parse_curie("omim:1234", context="chebi") # normally, OMIM works, but we configured a specific one for the blocklist with self.assertRaises(BlocklistError): self.converter.parse_curie("omim:1356", context="chebi") self.assertIsNone( self.converter.parse_curie("omim:1356", context="chebi", block_action="pass") ) def test_global_blocklist(self) -> None: """Test global blocklist.""" with self.assertRaises(BlocklistError): self.converter.parse("rdf:NOPE") self.assertIsNone(self.converter.parse("rdf:NOPE", block_action="pass")) with self.assertRaises(BlocklistError): self.converter.parse_curie("rdf:NOPE") self.assertIsNone(self.converter.parse_curie("rdf:NOPE", block_action="pass")) with self.assertRaises(BlocklistError): self.converter.parse_uri("rdf:NOPE") self.assertIsNone(self.converter.parse_uri("rdf:NOPE", block_action="pass")) def test_resource_specific_suffix_rewrite(self) -> None: """Test resource-specific suffix rewrites.""" target = ReferenceTuple("emedicine", "276512") for uri in [ "http://emedicine.medscape.com/article/276512", # clean "http://emedicine.medscape.com/article/276512-overview", # dirty ]: with self.subTest(uri=uri): self.assertEqual(target, self.converter.parse(uri)) biopragmatics-curies-aa8bd37/tests/test_reconciliation.py000066400000000000000000000347171525104130300241040ustar00rootroot00000000000000"""Tests for reconciliation.""" import unittest from curies import Converter, Record, remap_curie_prefixes, remap_uri_prefixes, rewire from curies.reconciliation import ( CycleDetected, DuplicateKeys, DuplicateValues, InconsistentMapping, _order_curie_remapping, ) #: The beginning of URIs used throughout examples P = "https://example.org" class TestUtils(unittest.TestCase): """Test utilities.""" def test_ordering(self) -> None: """Test ordering.""" converter = Converter( [ Record(prefix="a", uri_prefix=f"{P}/a/"), Record(prefix="b", uri_prefix=f"{P}/b/"), Record(prefix="c", uri_prefix=f"{P}/c/"), ] ) self.assertEqual( [("a", "a1"), ("b", "b1")], _order_curie_remapping(converter, {"a": "a1", "b": "b1"}) ) # we want to be as low down the chain first. Test both constructions of the dictionary self.assertEqual( [("c", "a"), ("b", "c")], _order_curie_remapping(converter, {"c": "a", "b": "c"}) ) self.assertEqual( [("c", "a"), ("b", "c")], _order_curie_remapping(converter, {"b": "c", "c": "a"}) ) def test_duplicate_values(self) -> None: """Test detecting bad mapping with duplicate.""" converter = Converter( [ Record(prefix="a", uri_prefix=f"{P}/a/"), Record(prefix="b", uri_prefix=f"{P}/b/"), Record(prefix="c", uri_prefix=f"{P}/c/"), ] ) curie_remapping = {"b": "c", "a": "c"} with self.assertRaises(DuplicateValues): _order_curie_remapping(converter, curie_remapping) def test_duplicate_keys(self) -> None: """Test detecting a bad mapping that contains multiple references to the same record in the keys.""" converter = Converter( [ Record(prefix="a", prefix_synonyms=["a1"], uri_prefix=f"{P}/a/"), Record(prefix="b", uri_prefix=f"{P}/b/"), Record(prefix="c", uri_prefix=f"{P}/c/"), ] ) curie_remapping = {"a": "c", "a1": "b"} with self.assertRaises(DuplicateKeys): _order_curie_remapping(converter, curie_remapping) def test_duplicate_correspondence(self) -> None: """Test detecting a bad mapping containing inconsistent references to the same record in the keys and values.""" converter = Converter( [ Record(prefix="a", prefix_synonyms=["a1"], uri_prefix=f"{P}/a/"), Record(prefix="b", uri_prefix=f"{P}/b/"), Record(prefix="c", uri_prefix=f"{P}/c/"), ] ) curie_remapping = {"a": "c", "b": "a1"} with self.assertRaises(InconsistentMapping): _order_curie_remapping(converter, curie_remapping) def test_cycles(self) -> None: """Test detecting bad mapping with cycles.""" converter = Converter( [ Record(prefix="a", uri_prefix=f"{P}/a/"), Record(prefix="b", uri_prefix=f"{P}/b/"), Record(prefix="c", uri_prefix=f"{P}/c/"), ] ) curie_remapping = {"b": "c", "c": "b"} with self.assertRaises(CycleDetected): remap_curie_prefixes(converter, curie_remapping) curie_remapping = {"a": "b", "b": "c", "c": "a"} with self.assertRaises(CycleDetected): _order_curie_remapping(converter, curie_remapping) class TestCURIERemapping(unittest.TestCase): """A test case for CURIE prefix remapping.""" def test_missing(self) -> None: """Test simple upgrade.""" records = [ Record(prefix="a", prefix_synonyms=["x"], uri_prefix=f"{P}/a/"), ] converter = Converter(records) curie_remapping = {"b": "c"} converter = remap_curie_prefixes(converter, curie_remapping) self.assertEqual(records, converter.records) def test_simple(self) -> None: """Test simple upgrade.""" records = [ Record(prefix="a", prefix_synonyms=["x"], uri_prefix=f"{P}/a/"), ] converter = Converter(records) curie_remapping = {"a": "a1"} converter = remap_curie_prefixes(converter, curie_remapping) self.assertEqual(1, len(converter)) self.assertEqual( Record(prefix="a1", prefix_synonyms=["a", "x"], uri_prefix=f"{P}/a/"), converter.records[0], ) def test_synonym(self) -> None: """Test that an upgrade configuration that would cause a clash does nothing.""" records = [ Record(prefix="a", prefix_synonyms=["x"], uri_prefix=f"{P}/a/"), ] converter = Converter(records) curie_remapping = {"a": "x"} converter = remap_curie_prefixes(converter, curie_remapping) self.assertEqual(1, len(converter)) self.assertEqual( Record(prefix="x", prefix_synonyms=["a"], uri_prefix=f"{P}/a/"), converter.records[0], ) def test_clash(self) -> None: """Test that an upgrade configuration that would cause a clash does nothing.""" records = [ Record(prefix="a", prefix_synonyms=["x"], uri_prefix=f"{P}/a/"), Record(prefix="b", prefix_synonyms=["y"], uri_prefix=f"{P}/b/"), ] converter = Converter(records) curie_remapping = {"a": "b"} converter = remap_curie_prefixes(converter, curie_remapping) self.assertEqual(2, len(converter)) self.assertEqual(records, converter.records) def test_clash_synonym(self) -> None: """Test a clash on a synonym.""" records = [ Record(prefix="a", prefix_synonyms=["x"], uri_prefix=f"{P}/a/"), Record(prefix="b", prefix_synonyms=["y"], uri_prefix=f"{P}/b/"), ] converter = Converter(records) curie_remapping = {"a": "y"} converter = remap_curie_prefixes(converter, curie_remapping) self.assertEqual(2, len(converter)) self.assertEqual(records, converter.records) def test_simultaneous(self) -> None: """Test simultaneous remapping.""" records = [ Record(prefix="geo", uri_prefix="https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc="), Record(prefix="geogeo", uri_prefix="http://purl.obolibrary.org/obo/GEO_"), ] converter = Converter(records) curie_remapping = {"geo": "ncbi.geo", "geogeo": "geo"} converter = remap_curie_prefixes(converter, curie_remapping) self.assertEqual( [ Record( prefix="geo", prefix_synonyms=["geogeo"], uri_prefix="http://purl.obolibrary.org/obo/GEO_", ), Record( prefix="ncbi.geo", uri_prefix="https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=", ), ], converter.records, ) def test_simultaneous_synonym(self) -> None: """Test simultaneous remapping with synonyms raises an error.""" records = [ Record( prefix="geo", prefix_synonyms=["ggg"], uri_prefix="https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=", ), Record(prefix="geogeo", uri_prefix="http://purl.obolibrary.org/obo/GEO_"), ] converter = Converter(records) curie_remapping = {"ggg": "ncbi.geo", "geogeo": "geo"} with self.assertRaises(InconsistentMapping): remap_curie_prefixes(converter, curie_remapping) class TestURIRemapping(unittest.TestCase): """A test case for URI prefix remapping.""" def test_transitive_error(self) -> None: """Test error on transitive remapping.""" converter = Converter([]) uri_remapping = {f"{P}/nope/": f"{P}/more-nope/", f"{P}/more-nope/": f"{P}/more-more-nope/"} with self.assertRaises(NotImplementedError) as e: remap_uri_prefixes(converter, uri_remapping) # check that stringification works self.assertIn("75", str(e.exception)) def test_missing(self) -> None: """Test simple upgrade.""" records = [ Record(prefix="a", uri_prefix=f"{P}/a/"), ] converter = Converter(records) uri_remapping = {f"{P}/nope/": f"{P}/more-nope/"} converter = remap_uri_prefixes(converter, uri_remapping) self.assertEqual(records, converter.records) def test_simple(self) -> None: """Test simple upgrade.""" records = [ Record(prefix="a", uri_prefix=f"{P}/a/", uri_prefix_synonyms=[f"{P}/a1/"]), ] converter = Converter(records) uri_remapping = {f"{P}/a/": f"{P}/a2/"} converter = remap_uri_prefixes(converter, uri_remapping) self.assertEqual(1, len(converter)) self.assertEqual( Record( prefix="a", uri_prefix=f"{P}/a2/", uri_prefix_synonyms=[f"{P}/a/", f"{P}/a1/"], ), converter.records[0], ) def test_synonym(self) -> None: """Test that an upgrade configuration that would cause a clash does nothing.""" records = [ Record(prefix="a", uri_prefix=f"{P}/a/", uri_prefix_synonyms=[f"{P}/a1/"]), ] converter = Converter(records) uri_remapping = {f"{P}/a1/": f"{P}/a2/"} converter = remap_uri_prefixes(converter, uri_remapping) self.assertEqual(1, len(converter)) self.assertEqual( Record(prefix="a", uri_prefix=f"{P}/a2/", uri_prefix_synonyms=[f"{P}/a/", f"{P}/a1/"]), converter.records[0], ) def test_clash_preferred(self) -> None: """Test that an upgrade configuration that would cause a clash does nothing.""" records = [ Record(prefix="a", prefix_synonyms=["x"], uri_prefix=f"{P}/a/"), Record(prefix="b", prefix_synonyms=["y"], uri_prefix=f"{P}/b/"), ] converter = Converter(records) upgrades = {f"{P}/a/": f"{P}/b/"} converter = remap_uri_prefixes(converter, upgrades) self.assertEqual(2, len(converter)) self.assertEqual(records, converter.records) def test_clash_synonym(self) -> None: """Test clashing with a synonym.""" records = [ Record(prefix="a", uri_prefix=f"{P}/a/"), Record(prefix="b", uri_prefix=f"{P}/b/", uri_prefix_synonyms=[f"{P}/b1/"]), ] converter = Converter(records) upgrades = {f"{P}/a/": f"{P}/b1/"} converter = remap_uri_prefixes(converter, upgrades) self.assertEqual(2, len(converter)) self.assertEqual(records, converter.records) class TestRewire(unittest.TestCase): """A test case for rewiring.""" def test_idempotent(self) -> None: """Test that a redundant rewiring doesn't do anything.""" records = [ Record(prefix="a", uri_prefix=f"{P}/a/", uri_prefix_synonyms=["https://a.org/"]), ] converter = Converter(records) rewiring = {"a": f"{P}/a/"} converter = rewire(converter, rewiring) self.assertEqual(records, converter.records) def test_upgrade_uri_prefixes_simple(self) -> None: """Test simple upgrade.""" records = [ Record(prefix="a", uri_prefix=f"{P}/a/", uri_prefix_synonyms=["https://a.org/"]), ] converter = Converter(records) rewiring = {"a": f"{P}/a1/"} converter = rewire(converter, rewiring) self.assertEqual(1, len(converter)) self.assertEqual( Record( prefix="a", uri_prefix=f"{P}/a1/", uri_prefix_synonyms=["https://a.org/", f"{P}/a/"] ), converter.records[0], ) # def test_upgrade_uri_prefixes_add(self): # """Test an upgrade that adds an extra prefix.""" # records = [ # Record(prefix="a", uri_prefix=f"{P}/a/"), # ] # converter = Converter(records) # rewiring = {"b": f"{P}/b/"} # converter = rewire(converter, rewiring) # self.assertEqual(2, len(converter)) # self.assertEqual( # [ # Record(prefix="a", uri_prefix=f"{P}/a/"), # Record(prefix="b", uri_prefix=f"{P}/b/"), # ], # converter.records, # ) def test_upgrade_uri_prefixes_clash(self) -> None: """Test an upgrade that does nothing since it would create a clash.""" records = [ Record(prefix="a", uri_prefix=f"{P}/a/"), Record(prefix="b", uri_prefix=f"{P}/b/"), ] converter = Converter(records) rewiring = {"b": f"{P}/a/"} converter = rewire(converter, rewiring) self.assertEqual(2, len(converter)) self.assertEqual( [ Record(prefix="a", uri_prefix=f"{P}/a/"), Record(prefix="b", uri_prefix=f"{P}/b/"), ], converter.records, ) def test_upgrade_uri_upgrade(self) -> None: """Test an upgrade of an existing URI prefix synonym.""" records = [ Record(prefix="a", uri_prefix=f"{P}/a/", uri_prefix_synonyms=[f"{P}/a1/"]), ] converter = Converter(records) rewiring = {"a": f"{P}/a1/"} converter = rewire(converter, rewiring) self.assertEqual(1, len(converter)) self.assertEqual( [ Record( prefix="a", uri_prefix=f"{P}/a1/", uri_prefix_synonyms=[f"{P}/a/"], ), ], converter.records, ) def test_upgrade_uri_upgrade_with_curie_prefix(self) -> None: """Test an upgrade of an existing URI prefix synonym via a CURIE prefix synonym.""" records = [ Record( prefix="a", prefix_synonyms=["a1"], uri_prefix=f"{P}/a/", uri_prefix_synonyms=[f"{P}/a1/"], ), ] converter = Converter(records) rewiring = {"a1": f"{P}/a1/"} converter = rewire(converter, rewiring) self.assertEqual(1, len(converter)) self.assertEqual( [ Record( prefix="a", prefix_synonyms=["a1"], uri_prefix=f"{P}/a1/", uri_prefix_synonyms=[f"{P}/a/"], ), ], converter.records, ) biopragmatics-curies-aa8bd37/tests/test_resolver_service.py000066400000000000000000000063551525104130300244600ustar00rootroot00000000000000"""Tests for the simple web service.""" import unittest from typing import ClassVar from fastapi.testclient import TestClient from curies import Converter from curies.resolver_service import FAILURE_CODE, get_fastapi_app, get_flask_app class ConverterMixin(unittest.TestCase): """A mixin that has a converter.""" delimiter: ClassVar[str] = ":" def setUp(self) -> None: """Set up the test case with a converter.""" super().setUp() self.converter = Converter.from_prefix_map( { "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", "MONDO": "http://purl.obolibrary.org/obo/MONDO_", "GO": "http://purl.obolibrary.org/obo/GO_", "OBO": "http://purl.obolibrary.org/obo/", }, delimiter=self.delimiter, ) class TestFastAPI(ConverterMixin): """Test building a simple web service with FastAPI.""" def setUp(self) -> None: """Set up the test case with a converter, blueprint, and app.""" super().setUp() self.app = get_fastapi_app(self.converter) self.client = TestClient(self.app) def test_resolve_success(self) -> None: """Test resolution for a valid CURIE redirects properly.""" curie = self.converter.format_curie("GO", "1234567") res = self.client.get(f"/{curie}", follow_redirects=False) self.assertEqual(302, res.status_code, msg=res.text) def test_resolve_failure(self) -> None: """Test resolution for an invalid CURIE aborts with 404.""" curie = self.converter.format_curie("NOPREFIX", "NOIDENTIFIER") res = self.client.get(f"/{curie}", follow_redirects=False) self.assertEqual(FAILURE_CODE, res.status_code, msg=res.text) class TestFastAPISlashed(TestFastAPI): """Test the FastAPI router with an alternate delimiter.""" delimiter = "/" def test_delimiter(self) -> None: """Test the delimiter.""" self.assertEqual("/", self.converter.delimiter) class TestFlaskBlueprint(ConverterMixin): """Test building a simple web service with Flask.""" def setUp(self) -> None: """Set up the test case with a converter, blueprint, and app.""" super().setUp() self.app = get_flask_app(self.converter) def test_resolve_success(self) -> None: """Test resolution for a valid CURIE redirects properly.""" curie = self.converter.format_curie("GO", "1234567") with self.app.test_client() as client: res = client.get(f"/{curie}", follow_redirects=False) self.assertEqual(302, res.status_code, msg=res.text) def test_resolve_failure(self) -> None: """Test resolution for an invalid CURIE aborts with 404.""" curie = self.converter.format_curie("NOPREFIX", "NOIDENTIFIER") with self.app.test_client() as client: res = client.get(f"/{curie}", follow_redirects=False) self.assertEqual(FAILURE_CODE, res.status_code, msg=res.text) class TestFlaskBlueprintSlashed(TestFlaskBlueprint): """Test the flask blueprint with an alternate delimiter.""" delimiter = "/" def test_delimiter(self) -> None: """Test the delimiter.""" self.assertEqual("/", self.converter.delimiter) biopragmatics-curies-aa8bd37/tests/test_struct.py000066400000000000000000000161161525104130300224170ustar00rootroot00000000000000"""Tests for the structure.""" from __future__ import annotations import unittest from pydantic import ValidationError import curies from curies.api import ( Converter, NamableReference, NamedReference, Records, Reference, ReferenceTuple, ) from curies.utils import NoCURIEDelimiterError CHEBI_URI_PREFIX = "http://purl.obolibrary.org/obo/CHEBI_" class TestStruct(unittest.TestCase): """Test the data structures.""" def test_not_curie(self) -> None: """Test a malformed CURIE.""" with self.assertRaises(NoCURIEDelimiterError) as e: Reference.from_curie("not a curie") self.assertIn("does not appear to be a CURIE", str(e.exception)) def test_curie_with_space(self) -> None: """Test a malformed CURIE.""" with self.assertRaises(ValidationError) as e: Reference(prefix="test", identifier="not a curie") self.assertIn( "local identifiers can not", str(e.exception), ) with self.assertRaises(ValidationError) as e: Reference.from_curie("test:not a curie") self.assertIn("local identifiers can not", str(e.exception)) def test_default_prefix(self) -> None: """Test a default (empty) prefix.""" ref = Reference.from_curie(":something") self.assertEqual("", ref.prefix) self.assertEqual("something", ref.identifier) def test_default_identifier(self) -> None: """Test a default (empty) identifier.""" ref = Reference.from_curie("p1:") self.assertEqual("p1", ref.prefix) self.assertEqual("", ref.identifier) def test_multiple_delimiters(self) -> None: """Test a default (empty) identifier.""" ref = Reference.from_curie("a1:b2:c3") self.assertEqual("a1", ref.prefix) self.assertEqual("b2:c3", ref.identifier) def test_records(self) -> None: """Test a list of records.""" records = Records.model_validate([{"prefix": "chebi", "uri_prefix": CHEBI_URI_PREFIX}]) converter = Converter(records=records) self.assertEqual({"chebi"}, converter.get_prefixes()) def test_sort(self) -> None: """Test sorting.""" start = [ Reference.from_curie("def:1234"), Reference.from_curie("abc:1234"), Reference.from_curie("abc:1235"), ] expected = [ Reference.from_curie("abc:1234"), Reference.from_curie("abc:1235"), Reference.from_curie("def:1234"), ] self.assertEqual(expected, sorted(start)) def test_set_membership(self) -> None: """Test membership in sets.""" collection = { Reference.from_curie("def:1234"), Reference.from_curie("abc:1234"), Reference.from_curie("abc:1235"), } self.assertIn(Reference.from_curie("def:1234"), collection) self.assertNotIn(Reference.from_curie("xyz:1234"), collection) self.assertNotIn(Reference.from_curie(":1234"), collection) self.assertNotIn(Reference.from_curie("abc:"), collection) def test_named_set_membership(self) -> None: """Test membership in sets of named references.""" references = { NamedReference.from_curie("a:1", "name1"), NamedReference.from_curie("a:2", "name2"), } self.assertIn(Reference.from_curie("a:1"), references) self.assertIn(NamableReference.from_curie("a:1"), references) self.assertIn(NamedReference.from_curie("a:1", "name1"), references) self.assertIn(NamableReference.from_curie("a:1", "name1"), references) # the following is a weird case, but shows how this works self.assertIn(NamedReference.from_curie("a:1", "name2"), references) references_2 = { Reference.from_curie("a:1"), Reference.from_curie("a:2"), } self.assertIn(Reference.from_curie("a:1"), references_2) self.assertIn(NamableReference.from_curie("a:1", "name1"), references_2) self.assertIn(NamedReference.from_curie("a:1", "name1"), references_2) def test_tuple(self) -> None: """Test reference tuples.""" t = ReferenceTuple.from_curie("a:1") self.assertEqual(Reference(prefix="a", identifier="1"), t.to_pydantic()) self.assertEqual( NamedReference(prefix="a", identifier="1", name="name"), t.to_pydantic(name="name") ) with self.assertRaises(ValueError): t.to_pydantic(name="") def test_reference_constructor(self) -> None: """Test constructing a reference.""" r1 = Reference(prefix="a", identifier="1") r2 = NamableReference(prefix="a", identifier="2") r3 = NamableReference(prefix="a", identifier="3", name="item 3") r4 = NamedReference(prefix="a", identifier="4", name="item 4") self.assertEqual(Reference(prefix="a", identifier="1"), Reference.from_reference(r1)) self.assertEqual(Reference(prefix="a", identifier="2"), Reference.from_reference(r2)) self.assertEqual(Reference(prefix="a", identifier="3"), Reference.from_reference(r3)) self.assertEqual(Reference(prefix="a", identifier="4"), Reference.from_reference(r4)) self.assertEqual( NamableReference(prefix="a", identifier="1", name=None), NamableReference.from_reference(r1), ) self.assertEqual( NamableReference(prefix="a", identifier="2", name=None), NamableReference.from_reference(r2), ) self.assertEqual( NamableReference(prefix="a", identifier="3", name="item 3"), NamableReference.from_reference(r3), ) self.assertEqual( NamableReference(prefix="a", identifier="4", name="item 4"), NamableReference.from_reference(r4), ) with self.assertRaises(TypeError): NamedReference.from_reference(r1) with self.assertRaises(ValidationError): NamedReference.from_reference(r2) self.assertEqual( NamedReference(prefix="a", identifier="3", name="item 3"), NamedReference.from_reference(r3), ) self.assertEqual( NamedReference(prefix="a", identifier="4", name="item 4"), NamedReference.from_reference(r4), ) def test_without_name(self) -> None: """Test removing names.""" c1 = Reference.from_curie("a:1") c2 = NamableReference.from_curie("a:1") c3 = NamableReference.from_curie("a:1", name="test") c4 = NamedReference.from_curie("a:1", name="test") for reference in [c1, c2, c3, c4]: new = reference.without_name() self.assertIsInstance(new, Reference) self.assertNotIsInstance(new, NamableReference) def test_with_name(self) -> None: """Test with name.""" r1 = curies.Reference.from_curie("chebi:1234") r2 = r1.with_name("test") self.assertIsInstance(r2, NamedReference) r3 = r2.without_name() self.assertIsInstance(r3, Reference) self.assertNotIsInstance(r3, NamableReference) biopragmatics-curies-aa8bd37/tests/test_triples/000077500000000000000000000000001525104130300221765ustar00rootroot00000000000000biopragmatics-curies-aa8bd37/tests/test_triples/__init__.py000066400000000000000000000000311525104130300243010ustar00rootroot00000000000000"""Tests for triples.""" biopragmatics-curies-aa8bd37/tests/test_triples/test_filter.py000066400000000000000000000166721525104130300251100ustar00rootroot00000000000000"""Test filter functions.""" import unittest from collections.abc import Iterable from curies import Converter, Reference, Triple from curies.triples import ( exclude_object_prefixes, exclude_prefixes_both, exclude_references_both, exclude_same_prefixes, exclude_subject_prefixes, exclude_triples, keep_object_prefixes, keep_predicates, keep_prefixes_both, keep_prefixes_either, keep_references_both, keep_references_either, keep_subject_prefixes, keep_triples_by_hash, ) from curies.vocabulary import exact_match, subclass_of p1, p2, p3 = "DOID", "mesh", "umls" c1, c2, c3, c4 = "DOID:0050577", "mesh:C562966", "umls:C4551571", "DOID:225" r1, r2, r3, r4 = (Reference.from_curie(c) for c in [c1, c2, c3, c4]) m1 = Triple.from_curies(c1, exact_match.curie, c2) m2 = Triple.from_curies(c2, exact_match.curie, c3) m3 = Triple.from_curies(c1, exact_match.curie, c3) m4 = Triple.from_curies(c1, subclass_of.curie, c4) M123 = [m1, m2, m3] converter = Converter.from_prefix_map( { "DOID": "http://purl.obolibrary.org/obo/DOID_", "skos": "http://www.w3.org/2004/02/skos/core#", "mesh": "http://id.nlm.nih.gov/mesh/", "umls": "https://uts.nlm.nih.gov/uts/umls/concept/", } ) def _x(triples: Iterable[Triple]) -> str: return ", ".join("-".join(e.as_str_triple()) for e in triples) class TestFilters(unittest.TestCase): """Test filters.""" def assert_triple_lists(self, expected: list[Triple], actual: Iterable[Triple]) -> None: """Test two triple lists are the same.""" actual = list(actual) self.assertEqual(expected, actual, msg=f"\nExpected: {_x(expected)}\nActual: {_x(actual)}") def test_exclude_object_prefixes(self) -> None: """Test excluding object prefixes.""" self.assert_triple_lists([m1], exclude_object_prefixes(M123, "umls")) self.assert_triple_lists([m1], exclude_object_prefixes(M123, {"umls"})) self.assert_triple_lists([m2, m3], exclude_object_prefixes(M123, {"mesh"})) self.assert_triple_lists(M123, exclude_object_prefixes(M123, {"DOID"})) def test_exclude_prefixes(self) -> None: """Test excluding prefixes.""" self.assert_triple_lists([m1], exclude_prefixes_both(M123, "umls")) self.assert_triple_lists([m1], exclude_prefixes_both(M123, {"umls"})) self.assert_triple_lists([m2], exclude_prefixes_both(M123, {"DOID"})) self.assert_triple_lists([m3], exclude_prefixes_both(M123, {"mesh"})) def test_exclude_subject_prefixes(self) -> None: """Test excluding subject prefixes.""" self.assert_triple_lists([m2], exclude_subject_prefixes(M123, "DOID")) self.assert_triple_lists([m2], exclude_subject_prefixes(M123, {"DOID"})) self.assert_triple_lists(M123, exclude_subject_prefixes(M123, {"umls"})) self.assert_triple_lists([m1, m3], exclude_subject_prefixes(M123, {"mesh"})) def test_exclude_same_prefixes(self) -> None: """Test excluding same prefixes.""" self.assert_triple_lists(M123, exclude_same_prefixes([m1, m2, m3, m4])) def test_exclude_triples(self) -> None: """Test excluding triples.""" self.assert_triple_lists([m1, m2], exclude_triples(M123, m3)) self.assert_triple_lists([m1, m2], exclude_triples(M123, [m3])) def test_keep_object_prefixes(self) -> None: """Test keeping object prefixes.""" self.assert_triple_lists([m2, m3], keep_object_prefixes(M123, "umls")) self.assert_triple_lists([m2, m3], keep_object_prefixes(M123, {"umls"})) def test_keep_prefixes_both(self) -> None: """Test keeping prefixes.""" with self.assertRaises(ValueError): keep_prefixes_both(M123, {"DOID"}) self.assert_triple_lists([], keep_prefixes_both(M123, {"NOPE", "also nope"})) self.assert_triple_lists([m1], keep_prefixes_both(M123, {"DOID", "mesh"})) self.assert_triple_lists([m3], keep_prefixes_both(M123, {"DOID", "umls"})) self.assert_triple_lists([m2], keep_prefixes_both(M123, {"mesh", "umls"})) self.assert_triple_lists(M123, keep_prefixes_both(M123, {"DOID", "umls", "mesh"})) def test_keep_prefixes_either(self) -> None: """Test keeping prefixes.""" self.assert_triple_lists([], keep_prefixes_either(M123, {"NOPE", "also nope"})) self.assert_triple_lists([m1, m2], keep_prefixes_either(M123, "mesh")) self.assert_triple_lists([m1, m3], keep_prefixes_either(M123, "DOID")) self.assert_triple_lists([m2, m3], keep_prefixes_either(M123, "umls")) self.assert_triple_lists([m1, m2, m3], keep_prefixes_either(M123, {"DOID", "mesh"})) self.assert_triple_lists([m1, m2, m3], keep_prefixes_either(M123, {"DOID", "umls"})) self.assert_triple_lists([m1, m2, m3], keep_prefixes_either(M123, {"mesh", "umls"})) self.assert_triple_lists(M123, keep_prefixes_either(M123, {"DOID", "umls", "mesh"})) def test_keep_subject_prefixes(self) -> None: """Test keeping subject prefixes.""" self.assert_triple_lists([m1, m3], keep_subject_prefixes(M123, "DOID")) self.assert_triple_lists([m1, m3], keep_subject_prefixes(M123, {"DOID"})) def test_keep_triple_by_hash(self) -> None: """Test keeping triples by hash.""" self.assert_triple_lists( [m1], keep_triples_by_hash(M123, converter, converter.hash_triple(m1)) ) self.assert_triple_lists( [m1, m2], keep_triples_by_hash( M123, converter, [converter.hash_triple(m2), converter.hash_triple(m1)] ), ) def test_keep_references_either(self) -> None: """Test keeping references.""" self.assert_triple_lists([m1, m3], keep_references_either(M123, r1)) self.assert_triple_lists([m1, m3], keep_references_either(M123, [r1])) self.assert_triple_lists([m1, m2], keep_references_either(M123, [r2])) self.assert_triple_lists([m2, m3], keep_references_either(M123, [r3])) self.assert_triple_lists(M123, keep_references_either(M123, [r1, r2])) self.assert_triple_lists(M123, keep_references_either(M123, [r2, r3])) self.assert_triple_lists(M123, keep_references_either(M123, [r1, r2, r3])) def test_keep_references_both(self) -> None: """Test keeping references.""" with self.assertRaises(ValueError): keep_references_both(M123, [r1]) self.assert_triple_lists([m1], keep_references_both(M123, [r1, r2])) self.assert_triple_lists([m2], keep_references_both(M123, [r2, r3])) self.assert_triple_lists([m3], keep_references_both(M123, [r1, r3])) self.assert_triple_lists(M123, keep_references_both(M123, [r1, r2, r3])) def test_exclude_references(self) -> None: """Test exclude references.""" self.assert_triple_lists([m2], exclude_references_both(M123, r1)) self.assert_triple_lists([m2], exclude_references_both(M123, [r1])) self.assert_triple_lists([m3], exclude_references_both(M123, [r2])) self.assert_triple_lists([m1], exclude_references_both(M123, [r3])) def test_keep_predicate(self) -> None: """Test keep predicate.""" self.assert_triple_lists([m1, m2, m3], keep_predicates([m1, m2, m3, m4], exact_match)) self.assert_triple_lists([m1, m2, m3], keep_predicates([m1, m2, m3, m4], [exact_match])) self.assert_triple_lists( [m1, m2, m3, m4], keep_predicates([m1, m2, m3, m4], [exact_match, subclass_of]) ) biopragmatics-curies-aa8bd37/tests/test_triples/test_models.py000066400000000000000000000073371525104130300251040ustar00rootroot00000000000000"""Tests for triples.""" import itertools as itt import tempfile import unittest from pathlib import Path import pydantic import curies from curies import Reference, Triple from curies.triples import encode_curie_triple, encode_uri_triple, read_triples, write_triples T1 = Triple.from_curies("a:1", "a:2", "a:3") T2 = Triple.from_curies("a:1", "a:2", "a:4") class TestTriples(unittest.TestCase): """Test triples.""" def test_immutable(self) -> None: """Test immutable.""" with self.assertRaises(pydantic.ValidationError): T1.subject = Reference.from_curie("b:1") # type:ignore def test_as_curies(self) -> None: """Test stringifying.""" self.assertEqual( ("a:1", "a:2", "a:3"), T1.as_str_triple(), ) def test_roundtrip(self) -> None: """Test roundtrip.""" triples = [T1, T2] with tempfile.TemporaryDirectory() as directory: paths = [ Path(directory).joinpath("test.tsv.gz"), Path(directory).joinpath("test.tsv"), ] headers = [None, ("a", "b", "c")] for path, header in itt.product(paths, headers): with self.subTest(path=path): write_triples(triples, path, header=header) reconstituted = read_triples(path) self.assertEqual(triples, reconstituted) def test_sort(self) -> None: """Test sorting.""" self.assertEqual([T1, T2], sorted([T1, T2])) self.assertEqual([T1, T2], sorted([T2, T1])) def test_hash_uri_triple(self) -> None: """Test encoding triples of URI strings.""" examples: list[tuple[str, str, str, str]] = [ ( # example 1 from https://ts4nfdi.github.io/mapping-sameness-identifier/ "95a088082ab2b2a68638aebbcc3fe3e0f229da75a8b5bdbb9f3f8cd5e1e4286e", "http://example.org/feline", "http://www.w3.org/2002/07/owl#sameAs", "http://example.com/cat", ), ( "36a1f9244ea7641a90987c82f33c25c0c13712ee8f48207b2a0825f8a4e4e26a", "http://id.nlm.nih.gov/mesh/C000089", "http://www.w3.org/2004/02/skos/core#exactMatch", "http://purl.obolibrary.org/obo/CHEBI_28646", ), ] for expected, s, p, o in examples: with self.subTest(): self.assertEqual(expected, encode_uri_triple((s, p, o))) def test_encode_curie_triple(self) -> None: """Test encoding triples of CURIE strings.""" converter = curies.load_prefix_map( { "mesh": "http://id.nlm.nih.gov/mesh/", "skos": "http://www.w3.org/2004/02/skos/core#", "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", } ) triple = ("mesh:C000089", "skos:exactMatch", "CHEBI:28646") triple_id = encode_curie_triple(triple, converter) self.assertEqual( "36a1f9244ea7641a90987c82f33c25c0c13712ee8f48207b2a0825f8a4e4e26a", triple_id, ) def test_hash_triple(self) -> None: """Test encoding Triple model.""" converter = curies.load_prefix_map( { "mesh": "http://id.nlm.nih.gov/mesh/", "skos": "http://www.w3.org/2004/02/skos/core#", "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", } ) triple = Triple(subject="mesh:C000089", predicate="skos:exactMatch", object="CHEBI:28646") triple_id = converter.hash_triple(triple) self.assertEqual( "36a1f9244ea7641a90987c82f33c25c0c13712ee8f48207b2a0825f8a4e4e26a", triple_id, ) biopragmatics-curies-aa8bd37/tests/test_triples/test_ops.py000066400000000000000000000144141525104130300244140ustar00rootroot00000000000000"""Test triples operations.""" import unittest from curies import Reference from curies.triples import Triple from curies.triples.ops import ( exclude_prefix_stratified_many_to_many, flip_prefix_pair_stratified_index, get_one_to_many, get_prefix_pair_stratified_indexes, get_prefix_stratified_many_to_many, get_reference_indexes, ) from curies.vocabulary import exact_match predicate = exact_match p11 = Reference.from_curie("p1:1") p12 = Reference.from_curie("p1:2") p13 = Reference.from_curie("p1:3") p14 = Reference.from_curie("p1:4") p15 = Reference.from_curie("p1:5") p16 = Reference.from_curie("p1:6") p17 = Reference.from_curie("p1:7") p2a = Reference.from_curie("p2:A") p2b = Reference.from_curie("p2:B") p2c = Reference.from_curie("p2:C") p2d = Reference.from_curie("p2:D") p2e = Reference.from_curie("p2:E") p2f = Reference.from_curie("p2:F") p3gamma = Reference.from_curie("p3:gamma") def _triple(a: Reference, b: Reference, c: Reference) -> Triple: return Triple(subject=a, predicate=b, object=c) # one-to-one m1 = _triple(p11, predicate, p2a) # one-to-many m2 = _triple(p12, predicate, p2b) m3 = _triple(p12, predicate, p2c) # many-to-one m4 = _triple(p14, predicate, p2d) m5 = _triple(p15, predicate, p2d) # many-to-many m6 = _triple(p16, predicate, p2e) m7 = _triple(p16, predicate, p2f) m8 = _triple(p17, predicate, p2e) m9 = _triple(p17, predicate, p2f) m10 = _triple(p11, predicate, p3gamma) # duplicate of m1 m11 = _triple(p11, predicate, p2a) triples = [m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11] class TestOperations(unittest.TestCase): """Test triples operations.""" def test_many_to_many_index(self) -> None: """Get getting a many-to-many index.""" forward, backward = get_prefix_pair_stratified_indexes(triples) with self.subTest(part="contents"): self.assertEqual( { ("p1", "p2"): { "1": {"A": [m1, m11]}, "2": {"B": [m2], "C": [m3]}, "4": {"D": [m4]}, "5": {"D": [m5]}, "6": {"E": [m6], "F": [m7]}, "7": {"E": [m8], "F": [m9]}, }, ("p1", "p3"): {"1": {"gamma": [m10]}}, }, forward, ) self.assertEqual( { ("p2", "p1"): { "A": {"1": [m1, m11]}, "B": {"2": [m2]}, "C": {"2": [m3]}, "D": {"4": [m4], "5": [m5]}, "E": {"6": [m6], "7": [m8]}, "F": {"6": [m7], "7": [m9]}, }, ("p3", "p1"): { "gamma": {"1": [m10]}, }, }, backward, ) with self.subTest(part="processing"): self.assertEqual( { ("p1", "p2"): { "2": {"B": [m2], "C": [m3]}, "6": {"E": [m6], "F": [m7]}, "7": {"E": [m8], "F": [m9]}, }, }, get_one_to_many(forward), ) self.assertEqual( { ("p2", "p1"): { "D": {"4": [m4], "5": [m5]}, "E": {"6": [m6], "7": [m8]}, "F": {"6": [m7], "7": [m9]}, } }, get_one_to_many(backward), ) self.assertEqual( { ("p1", "p2"): { "6": {"E": [m6], "F": [m7]}, "7": {"E": [m8], "F": [m9]}, }, }, flip_prefix_pair_stratified_index(get_one_to_many(backward)), ) def test_one_to_many(self) -> None: """Get getting a many-to-many index.""" triples = [m1, m2, m3] forward, backward = get_prefix_pair_stratified_indexes(triples) with self.subTest(part="contents"): self.assertEqual( { ("p1", "p2"): { "1": {"A": [m1]}, "2": {"B": [m2], "C": [m3]}, }, }, forward, ) self.assertEqual( { ("p2", "p1"): { "A": {"1": [m1]}, "B": {"2": [m2]}, "C": {"2": [m3]}, }, }, backward, ) with self.subTest(part="processing"): self.assertEqual( { ("p1", "p2"): { "2": {"B": [m2], "C": [m3]}, }, }, get_one_to_many(forward), ) self.assertEqual( {}, get_one_to_many(backward), ) self.assertEqual( {}, flip_prefix_pair_stratified_index(get_one_to_many(backward)), ) def test_simple_indexes(self) -> None: """Test getting many-to-many triples.""" forward, backward = get_reference_indexes(triples) self.assertEqual( { p11: {p2a, p3gamma}, p12: {p2b, p2c}, p14: {p2d}, p15: {p2d}, p16: {p2e, p2f}, p17: {p2e, p2f}, }, forward, ) self.assertEqual( { p2a: {p11}, p2b: {p12}, p2c: {p12}, p2d: {p14, p15}, p2e: {p16, p17}, p2f: {p16, p17}, p3gamma: {p11}, }, backward, ) def test_get_many_to_many(self) -> None: """Test getting many-to-many triples.""" many_to_many = {m6, m7, m8, m9} self.assertEqual(many_to_many, get_prefix_stratified_many_to_many(triples)) self.assertEqual( [m for m in triples if m not in many_to_many], list(exclude_prefix_stratified_many_to_many(triples)), ) biopragmatics-curies-aa8bd37/tests/test_types.py000066400000000000000000000110031525104130300222250ustar00rootroot00000000000000"""Test types.""" import unittest from pydantic import BaseModel, ValidationError from curies import Converter, Prefix, PrefixMap, Reference class WrappedPrefix(BaseModel): """A model wrapping a prefix.""" prefix: Prefix class WrappedPrefixMap(BaseModel): """A model wrapping a prefix map.""" prefix_map: PrefixMap class WrappedCURIE(BaseModel): """A model wrapping a reference.""" reference: Reference converter = Converter.from_extended_prefix_map( [ { "prefix": "CHEBI", "prefix_synonyms": ["chebi"], "uri_prefix": "http://purl.obolibrary.org/obo/CHEBI_", "uri_prefix_synonyms": [ "https://identifiers.org/chebi:", ], }, ] ) class TestTypes(unittest.TestCase): """Test types.""" def test_prefix(self) -> None: """Test instantiating prefixes.""" model_1 = WrappedPrefix.model_validate({"prefix": "hello"}) self.assertEqual("hello", model_1.prefix) model_2 = WrappedPrefix.model_validate({"prefix": "CHEBI"}) self.assertEqual("CHEBI", model_2.prefix) # Test that a synonym gets standardized properly model_3 = WrappedPrefix.model_validate({"prefix": "CHEBI"}, context=converter) self.assertEqual("CHEBI", model_3.prefix) # Test that a canonical prefix is passed through model_4 = WrappedPrefix.model_validate({"prefix": "chebi"}, context=converter) self.assertEqual("CHEBI", model_4.prefix) # Test that a synonym gets standardized properly, when passing context in a dict model_5 = WrappedPrefix.model_validate( {"prefix": "CHEBI"}, context={"converter": converter} ) self.assertEqual("CHEBI", model_5.prefix) # Test that a canonical prefix is passed through, when passing context in a dict model_6 = WrappedPrefix.model_validate( {"prefix": "chebi"}, context={"converter": converter} ) self.assertEqual("CHEBI", model_6.prefix) # Test an invalid prefix raises an error, when passing a converter directly with self.assertRaises(ValidationError): WrappedPrefix.model_validate({"prefix": "nope"}, context=converter) # Test an invalid prefix raises an error, when passing a converter in a dict with self.assertRaises(ValidationError): WrappedPrefix.model_validate({"prefix": "nope"}, context={"converter": converter}) def test_prefix_root_model(self) -> None: """Test the root model.""" dd = { "": "http://example.org", "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", } prefix_map = PrefixMap.model_validate(dd) self.assertEqual(dd, prefix_map.root) prefix_map = PrefixMap.model_validate( { "chebi": "http://purl.obolibrary.org/obo/CHEBI_", }, context=converter, ) self.assertEqual( { "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", }, prefix_map.root, ) with self.assertRaises(ValidationError): PrefixMap.model_validate( { "NOPE": "http://purl.obolibrary.org/obo/CHEBI_", }, context=converter, ) def test_prefix_map_wrapped(self) -> None: """Test a wrapped prefix map.""" dd = { "prefix_map": { "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_", } } wpm = WrappedPrefixMap.model_validate(dd) self.assertIn("CHEBI", wpm.prefix_map.root) def test_curie(self) -> None: """Test a wrapped CURIE.""" wpm = WrappedCURIE.model_validate( { "reference": "CHEBI:1234", } ) self.assertIn("CHEBI", wpm.reference.prefix) self.assertIn("1234", wpm.reference.identifier) self.assertIn("CHEBI:1234", wpm.reference.curie) with self.assertRaises(ValidationError): WrappedCURIE.model_validate({"reference": "NOPENOPENOPE"}) dd = {"reference": "CHEBI:1234"} wpm = WrappedCURIE.model_validate(dd, context=converter) self.assertIn("CHEBI", wpm.reference.prefix) self.assertIn("1234", wpm.reference.identifier) self.assertIn("CHEBI:1234", wpm.reference.curie) with self.assertRaises(ValidationError): WrappedCURIE.model_validate({"reference": "MONDO:1234"}, context=converter) biopragmatics-curies-aa8bd37/tests/test_w3c.py000066400000000000000000000027201525104130300215630ustar00rootroot00000000000000"""Test W3C validation.""" import unittest from pathlib import Path from curies.w3c import is_w3c_curie, is_w3c_prefix HERE = Path(__file__).parent.resolve() DIRECTORY = HERE.joinpath("resources") VALID_CURIES_PATH = DIRECTORY.joinpath("valid_curies.txt") INVALID_CURIES_PATH = DIRECTORY.joinpath("invalid_curies.txt") VALID_PREFIXES_PATH = DIRECTORY.joinpath("valid_prefixes.txt") INVALID_PREFIXES_PATH = DIRECTORY.joinpath("invalid_prefixes.txt") def _read(path: Path) -> list[str]: return path.read_text().splitlines() class TestValidators(unittest.TestCase): """Test W3C validation.""" def test_prefixes(self) -> None: """Test prefixes validation.""" for prefix in _read(VALID_PREFIXES_PATH): with self.subTest(prefix=prefix): self.assertTrue(is_w3c_prefix(prefix)) for prefix in _read(INVALID_PREFIXES_PATH): with self.subTest(prefix=prefix): self.assertFalse(is_w3c_prefix(prefix)) def test_curies(self) -> None: """Test CURIE validation.""" for curie in _read(VALID_CURIES_PATH): with self.subTest(curie=curie): self.assertTrue(is_w3c_curie(curie), msg="CURIE should test as valid, but did not") for curie in _read(INVALID_CURIES_PATH): with self.subTest(curie=curie): self.assertFalse( is_w3c_curie(curie), msg="CURIE should test as invalid, but did not" ) biopragmatics-curies-aa8bd37/tox.ini000066400000000000000000000201521525104130300176260ustar00rootroot00000000000000# Tox (http://tox.testrun.org/) is a tool for running tests # in multiple virtualenvs. This configuration file will run the # test suite on all supported python versions. To use it, "pip install tox" # and then run "tox" from this directory. [tox] # To use a PEP 517 build-backend you are required to configure tox to use an isolated_build: # https://tox.readthedocs.io/en/latest/example/package.html isolated_build = True # These environments are run in order if you just use `tox`: envlist = # always keep coverage-clean first coverage-clean # code formatters format # format-docs # Code quality assessment pyroma lint mypy # Documentation quality assurance docs-lint docstr-coverage docs-test # the actual tests py-pandas2 py-pandas3 doctests # always keep coverage-report last coverage-report [testenv] description = Run unit and integration tests. # Runs on the "tests" directory by default, or passes the positional # arguments from `tox -e py ... commands = coverage run -p -m pytest --durations=20 {posargs:tests} coverage combine coverage xml extras = # See the [project.optional-dependencies] entry in pyproject.toml for "tests" pandas flask fastapi rdflib sqlalchemy sqlmodel dependency_groups = tests deps = pandas2: pandas<3.0 pandas3: pandas>=3.0 [testenv:coverage-clean] description = Remove testing coverage artifacts. deps = coverage skip_install = true commands = coverage erase [testenv:doctests] description = Test that documentation examples run properly. commands = xdoctest -m src/curies dependency_groups = doctests [testenv:treon] description = Test that notebooks can run to completion commands = treon notebooks/ deps = treon [testenv:format] description = Format the code in a deterministic way using ruff. Note that ruff check should come before ruff format when using --fix (ref: https://github.com/astral-sh/ruff-pre-commit/blob/main/README.md) deps = ruff skip_install = true commands = ruff check --fix ruff format [testenv:lint] description = Check code quality using ruff and other tools. skip_install = true deps = ruff # https://github.com/akaihola/darglint2 for more information darglint2 commands = ruff check ruff format --check darglint2 --strictness short --docstring-style sphinx -v 2 src/ tests/ notebooks/ [testenv:pyroma] dependency_groups = pyroma skip_install = true commands = pyroma --min=10 . description = Run the pyroma tool to check the package friendliness of the project. [testenv:mypy] description = Run the mypy tool to check static typing on the project. dependency_groups = typing extras = pandas flask fastapi rdflib sqlmodel sqlalchemy commands = mypy --ignore-missing-imports --strict src/ tests/ [testenv:docs-lint] skip_install = true dependency_groups = docs-lint commands = doc8 docs/source/ description = Run the doc8 tool to check the style of the RST files in the project docs. [testenv:docstr-coverage] description = Run the docstr-coverage tool to check documentation coverage. skip_install = true deps = docstr-coverage commands = docstr-coverage src/ tests/ --skip-private --skip-magic [testenv:docs] description = Build the documentation locally, allowing warnings. extras = # See the [project.optional-dependencies] entry in pyproject.toml for "docs" pandas flask fastapi rdflib sqlalchemy sqlmodel dependency_groups = docs commands = python -m sphinx -b html -d docs/build/doctrees docs/source docs/build/html [testenv:docs-test] description = Test building the documentation in an isolated environment. Warnings are considered as errors via -W. changedir = docs dependency_groups = {[testenv:docs]dependency_groups} extras = {[testenv:docs]extras} commands = mkdir -p {envtmpdir} cp -r source {envtmpdir}/source python -m sphinx -W -b html -d {envtmpdir}/build/doctrees {envtmpdir}/source {envtmpdir}/build/html # python -m sphinx -W -b coverage -d {envtmpdir}/build/doctrees {envtmpdir}/source {envtmpdir}/build/coverage # cat {envtmpdir}/build/coverage/c.txt # cat {envtmpdir}/build/coverage/python.txt allowlist_externals = cp cat mkdir [testenv:coverage-report] deps = coverage[toml] skip_install = true commands = coverage report #################### # Deployment tools # #################### [testenv:bumpversion] description = Bump the version number commands = bump-my-version bump {posargs} skip_install = true passenv = HOME deps = bump-my-version [testenv:bumpversion-release] description = Remove the -dev tag from the version commands = bump-my-version bump release --tag skip_install = true passenv = HOME deps = bump-my-version [testenv:build] skip_install = true deps = uv uv_build commands = uv build --sdist --wheel --no-build-isolation ############ # Releases # ############ # In order to make a release to PyPI, you'll need to take the following steps: # # 1. Navigate to https://pypi.org/account/register/ to register for Test PyPI # 2. Navigate to https://pypi.org/manage/account/ and request to re-send a verification email. # This is not sent by default, and is required to set up 2-Factor Authentication. # 3. Get account recovery codes # 4. Set up 2-Factor Authentication # 5. Get an API token from https://pypi.org/manage/account/token/ # 6. Install keyring with `uv tool install keyring` # 7. Add your token to keyring with `keyring set https://upload.pypi.org/legacy/ __token__` [testenv:release] description = Release the code to PyPI so users can pip install it, using credentials from keyring skip_install = true deps = {[testenv:build]deps} uv keyring commands = {[testenv:build]commands} uv publish --username __token__ --keyring-provider subprocess --publish-url https://upload.pypi.org/legacy/ [testenv:release-via-env] description = Release the code to PyPI so users can pip install it, using credentials from the environment. skip_install = true deps = {[testenv:build]deps} uv commands = {[testenv:build]commands} uv publish --publish-url https://upload.pypi.org/legacy/ passenv = UV_PUBLISH_USERNAME UV_PUBLISH_PASSWORD [testenv:finish] description = Run a workflow that removes -dev from the version, creates a tagged release on GitHub, creates a release on PyPI, and bumps the version again. skip_install = true passenv = HOME deps = {[testenv:release]deps} bump-my-version commands = {[testenv:bumpversion-release]commands} {[testenv:release]commands} git push --tags bump-my-version bump patch git push allowlist_externals = git ################# # Test Releases # ################# # In order to test making a release to Test PyPI, you'll need to take the following steps: # # 1. Navigate to https://test.pypi.org/account/register/ to register for Test PyPI # 2. Navigate to https://test.pypi.org/manage/account/ and request to re-send a verification email. # This is not sent by default, and is required to set up 2-Factor Authentication. # 3. Get account recovery codes # 4. Set up 2-Factor Authentication # 5. Get an API token from https://test.pypi.org/manage/account/token/ # 6. Install keyring with `uv tool install keyring` # 7. Add your token to keyring with `keyring set https://test.pypi.org/legacy/ __token__` [testenv:testrelease] description = Release the code to the test PyPI site skip_install = true deps = {[testenv:build]deps} uv keyring commands = {[testenv:build]commands} uv publish --username __token__ --keyring-provider subprocess --publish-url https://test.pypi.org/legacy/ [testenv:testfinish] description = Run a workflow that removes -dev from the version, creates a tagged release on GitHub, creates a release on Test PyPI, and bumps the version again. skip_install = true passenv = HOME deps = {[testenv:testrelease]deps} bump-my-version commands = {[testenv:bumpversion-release]commands} {[testenv:testrelease]commands} git push --tags bump-my-version bump patch git push allowlist_externals = git