-
Step 1: Install R
-
-
Ensure that R is installed on your system. R has minimal dependencies
-and is very simple to install:
-
--
-Linux
-
-- Ubuntu / Debian:
sudo apt install r-base
-
-- Fedora:
sudo dnf install R
-
-- CentOS/RHEL:
sudo yum install R
-
-- Arch Linux:
sudo pacman -S r
-
-
-
--
-macOS (with Homebrew):
brew install r
-
--
-Other Systems:
-Visit the CRAN download
-page.
-
+
To be able to use the AMR Python package, it is required
+to install both R and the AMR R package.
+
+
Preparation: Install R and AMR R package
+
+
For Linux and macOS, this is just:
+
# Ubuntu / Debian
+sudo apt install r-base && Rscript -e 'install.packages("AMR")'
+# Fedora:
+sudo dnf install R && Rscript -e 'install.packages("AMR")'
+# CentOS/RHEL
+sudo yum install R && Rscript -e 'install.packages("AMR")'
+# Arch Linux
+sudo pacman -S r && Rscript -e 'install.packages("AMR")'
+# macOS
+brew install r && Rscript -e 'install.packages("AMR")'
+
For Windows, visit the CRAN
+download page in install R, then afterwards install the ‘AMR’
+package manually.
-
-
Step 2: Install the AMR package in R
-
-
On Linux and macOS, open Terminal and run:
-
Rscript -e 'install.packages("AMR")'
-
For other systems, open your R console and install the
-AMR package by running:
-
-
On any system, you can also install the latest development version of
-the AMR package by setting repos to our beta
-channel:
-
-
-
-
Step 3: Install rpy2 in Python
-
-
To install rpy2, simply run the following command in
-your terminal:
-
-
-
-
Step 4: Test rpy2 Installation
-
-
To ensure everything is set up correctly, you can test your
-installation by running the following Python script, which essentially
-runs R in the background:
-
import rpy2.robjects as ro
-
-# Test a simple R function from Python
-ro.r('1 + 1')
-
If this returns 2, you’re good to go!
+
+
Install AMR Python Package
+
+
Since the Python package is available on the official Python Package Index, you can
+just run:
+
Working with AMR in Python
-
Now that we have rpy2 set up, let’s walk through some
-practical examples of using the AMR package within
-Python.
+
Now that we have everything set up, let’s walk through some practical
+examples of using the AMR package within Python.
-
Example 1: Converting Taxonomic Data
+Example 1: Calculating AMR
-
Let’s start by converting taxonomic user input to valid taxonomy
-using the AMR package, from within Python:
-
import pandas as pd
-import rpy2.robjects as ro
-from rpy2.robjects.packages import importr
-from rpy2.robjects import pandas2ri
-
-# Load the AMR package from R
-amr = importr('AMR')
-
-# Example user dataset in Python
-data = pd.DataFrame({
- 'microorganism': ['E. coli', 'S. aureus', 'P. aeruginosa', 'K. pneumoniae']
-})
-
-# Apply mo_name() from the AMR package to the 'microorganism' column
-ro.globalenv['r_data'] = data
-ro.r('r_data$mo_name <- mo_name(r_data$microorganism)')
-
-# Retrieve and print the modified R DataFrame in Python
-result = ro.r('r_data')
-result = pandas2ri.rpy2py(result)
-print(result)
-
In this example, a Python dataset with microorganism names like
-E. coli and S. aureus is passed to the R function
-mo_name(). The result is an updated DataFrame
-that includes the standardised microorganism names based on the
-mo_name() function from the AMR package.
+
import AMR
+import pandas as pd
+
+df = AMR.example_isolates
+result = AMR.resistance(df["AMX"])
+print(result)
+
[0.59555556]
-
Example 2: Generating an Antibiogram
+Example 2: Generating Antibiograms
One of the core functions of the AMR package is
generating an antibiogram, a table that summarises the antimicrobial
susceptibility of bacterial isolates. Here’s how you can generate an
antibiogram from Python:
-
# Run an antibiogram in R from Python
-ro.r('result <- antibiogram(example_isolates, antibiotics = c(aminoglycosides(), carbapenems()))')
-
-# Retrieve the result in Python
-result = ro.r('as.data.frame(result)')
-print(result)
-
In this example, we generate an antibiogram by selecting
-aminoglycosides and carbapenems, two classes of antibiotics, and then
-convert the resulting R data frame into a Python-readable format.
-
-
-
Example 3: Filtering Data Based on Gram-Negative Bacteria
-
-
Let’s say you want to filter the dataset for Gram-negative bacteria
-and display their resistance to certain antibiotics:
-
# Filter for Gram-negative bacteria with intrinsic resistance to cefotaxime
-ro.r('result <- example_isolates[which(mo_is_gram_negative() & mo_is_intrinsic_resistant(ab = "cefotax")), c("bacteria", aminoglycosides(), carbapenems())]')
-
-# Retrieve the filtered result in Python
-result = ro.r('as.data.frame(result)')
-print(result)
-
This example uses the AMR functions
-mo_is_gram_negative() and
-mo_is_intrinsic_resistant() to filter the dataset and
-returns a subset of bacteria with resistance data.
-
-
-
Example 4: Customising the Antibiogram
-
-
You can easily customise the antibiogram by passing different
-antibiotics or microorganism transformations, as shown below:
-
# Customise the antibiogram with different settings
-ro.r('result <- antibiogram(example_isolates, antibiotics = c("TZP", "TZP+TOB", "TZP+GEN"), mo_transform = "gramstain")')
-
-# Retrieve and print the result
-result = ro.r('as.data.frame(result)')
-print(result)
-
Here, we use piperacillin/tazobactam (TZP) in combination with
-tobramycin (TOB) and gentamicin (GEN) to see how they perform against
-various Gram-negative bacteria.
+
result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]])
+print(result2a)
+
+
+
+
+
+
+
+
+
+
+| CoNS |
+7% (10/142) |
+73% (183/252) |
+30% (10/33) |
+
+
+| E. coli |
+50% (196/392) |
+88% (399/456) |
+94% (393/416) |
+
+
+| K. pneumoniae |
+0% (0/58) |
+96% (53/55) |
+89% (47/53) |
+
+
+| P. aeruginosa |
+0% (0/30) |
+100% (30/30) |
+None |
+
+
+| P. mirabilis |
+None |
+94% (34/36) |
+None |
+
+
+| S. aureus |
+6% (8/131) |
+90% (171/191) |
+None |
+
+
+| S. epidermidis |
+1% (1/91) |
+64% (87/136) |
+None |
+
+
+| S. hominis |
+None |
+80% (56/70) |
+None |
+
+
+| S. pneumoniae |
+100% (112/112) |
+None |
+100% (112/112) |
+
+
+
+
result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain")
+print(result2b)
+
+
+
+
+
+
+
+
+
+
+| Gram-negative |
+36% (226/631) |
+91% (621/684) |
+88% (565/641) |
+
+
+| Gram-positive |
+43% (305/703) |
+77% (560/724) |
+86% (296/345) |
+
+
+
+
In this example, we generate an antibiogram by selecting various
+antibiotics.
Conclusion
-
Using rpy2, you can easily integrate the power of R’s
-AMR package into your Python workflows. Whether you are
-generating antibiograms, analyzing resistance data, or performing
-complex filtering, rpy2 gives you the flexibility to run R
-code without leaving the Python environment. This makes it a perfect
-solution for teams working across both R and Python.
+
With the AMR Python package, Python users can now
+effortlessly call R functions from the AMR R package. This
+eliminates the need for complex rpy2 configurations and
+provides a clean, easy-to-use interface for antimicrobial resistance
+analysis. The examples provided above demonstrate how this can be
+applied to typical workflows, such as standardising microorganism and
+antimicrobial names or calculating resistance.
+
By using import AMR, you can seamlessly integrate the
+robust features of the R AMR package into your Python
+workflows. Whether you’re cleaning data or analysing resistance
+patterns, the AMR Python package makes it easy to work with
+AMR data in Python.
diff --git a/articles/EUCAST.html b/articles/EUCAST.html
index 1b8f24ef..37ce20b1 100644
--- a/articles/EUCAST.html
+++ b/articles/EUCAST.html
@@ -29,7 +29,7 @@
AMR (for R)
-
2.1.1.9094
+
2.1.1.9095