Metadata-Version: 2.4
Name: mgtx-benchling-wrapper
Version: 0.1.5
Summary: Python wrapper for Benchling API with common functions used at MGTX DSC
Author-email: Ana Valinhas <ana.valinhas@meiragtx.com>
License: MIT
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Requires-Python: >=3.10
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: benchling-sdk>=1.21.2
Requires-Dist: benchling-api-client>=2.0.342
Requires-Dist: pandas>=2.2.2
Requires-Dist: numpy>=1.26.4
Provides-Extra: dev
Requires-Dist: pytest>=9.0.3; extra == "dev"
Requires-Dist: pytest-mock>=3.15.1; extra == "dev"
Requires-Dist: build; extra == "dev"
Requires-Dist: twine; extra == "dev"
Dynamic: license-file

# mgtx-benchling-wrapper
A wrapper of the Benchling API SDK with common functions and workflows used at MGTX DSC.

## Installation 🚀
You can install this package using:
```
pip install mgtx-benchling-wrapper
```

## Quickstart 🚩
After creating an app on your Benchling tenant, create a config.yaml file in your repo.
The following is an example of the contents of a config.yaml

Note: You might want to keep the app client secret separated from your main code.
```
BenchlingCredentials:
  benchling_url: 'https://mytenant.benchling.com'
  benchling_access_token: 'https://mytenant.benchling.com/api/v2/token'
  app_client_id: 'your-app-client-id'
  app_client_secret: 'your-app-client-secret'
AssaySchema:
  schema_id: "schema_api_id"
Project:
  project_id: "project_api_id"
```
The following is an example of the use of the assay_results_ingestion workflow.
```
import yaml
from mgtx_benchling_wrapper import BenchlingContext
from mgtx_benchling_wrapper import BenchlingWrapperFacade
from mgtx_benchling_wrapper import AssayResultIngestionWorkflow
from mgtx_benchling_wrapper.utils.logger import get_logger

logger = get_logger(__name__,
                        file_log_level='DEBUG',
                        console_log_level='INFO', )

def config():
    with open("tests/config/test_config.yml") as f:
        return yaml.safe_load(f)

#create the benchling context        
ctx = BenchlingContext(
        base_url=config()['BenchlingCredentials']['benchling_url'],
        client_id=config()['BenchlingCredentials']['app_client_id'],
        client_secret=config()['BenchlingCredentials']['app_client_secret'],
        token_url=config()['BenchlingCredentials']['benchling_access_token'],
    )    

#initialize the wrapper
wrapper = BenchlingWrapperFacade(ctx.benchling())

#retrieve assay_schema_id
schema_id = config()['AssaySchema']['schema_id']

#retrieve project_id
project_id = config()['Project']['project_id']

#initiate results ingestion workflow
results_ingestion = AssayResultIngestionWorkflow(wrapper)

#ingest results on benchling
list_missing_entities = results_ingestion.assay_results_ingestion_updated(
        [dataframe_to_ingest],
        schema_id,
        project_id,
        unique_identifiers =['assay_run_id', 'sample_id']
        )       
```
Another example is accessing a Benchling assay results schema metadata.
```
#run the following after initializing the wrapper

from mgtx_benchling_wrapper import SchemaHandler

schema_handler = SchemaHandler(wrapper)

schema_definition = schema_handler.build_schema_definition(schema_id, 'assay_results_schema')
```
Another example is using a method from the wrapper directly to build your own workflow.
```
#run the following after initializing the wrapper

list_custom_entities = wrapper.custom_entities.get_by_names(['your-entity-1', 'your-entity-2'])

for custom_entity in list_custom_entities:
    name = wrapper.custom_entities.name()
    print(f"the name of the custom entity {custom_entity} is {name}.")
```
To release and publish run the following on gitBash to initialize the GitHub Action for
publishing the package.
```
git tag v0.1.#
git push origin v0.1.#
```
