code
stringlengths 66
870k
| docstring
stringlengths 19
26.7k
| func_name
stringlengths 1
138
| language
stringclasses 1
value | repo
stringlengths 7
68
| path
stringlengths 5
324
| url
stringlengths 46
389
| license
stringclasses 7
values |
|---|---|---|---|---|---|---|---|
def convert_github_url_to_raw(path_or_url: str) -> str:
"""Convert a GitHub URL to a raw URL if it's a GitHub URL, otherwise return the original path or URL."""
github_pattern = r"https?://(?:www\.)?github\.com/([^/]+)/([^/]+)/(?:blob|raw)/([^/]+)/(.+)"
github_match = re.match(github_pattern, path_or_url)
if github_match:
user, repo, branch, file_path = github_match.groups()
return f"https://raw.githubusercontent.com/{user}/{repo}/{branch}/{file_path}"
return path_or_url
|
Convert a GitHub URL to a raw URL if it's a GitHub URL, otherwise return the original path or URL.
|
convert_github_url_to_raw
|
python
|
mckinsey/vizro
|
vizro-mcp/src/vizro_mcp/_utils/utils.py
|
https://github.com/mckinsey/vizro/blob/master/vizro-mcp/src/vizro_mcp/_utils/utils.py
|
Apache-2.0
|
def load_dataframe_by_format(
path_or_url: Union[str, Path], mime_type: Optional[str] = None
) -> tuple[pd.DataFrame, Literal["pd.read_csv", "pd.read_json", "pd.read_html", "pd.read_excel", "pd.read_parquet"]]:
"""Load a dataframe based on file format determined by MIME type or file extension."""
file_path_str_lower = str(path_or_url).lower()
# Determine format
if mime_type == "text/csv" or file_path_str_lower.endswith(".csv"):
df = pd.read_csv(
path_or_url,
on_bad_lines="warn",
low_memory=False,
)
read_fn = "pd.read_csv"
elif mime_type == "application/json" or file_path_str_lower.endswith(".json"):
df = pd.read_json(path_or_url)
read_fn = "pd.read_json"
elif mime_type == "text/html" or file_path_str_lower.endswith((".html", ".htm")):
tables = pd.read_html(path_or_url)
if not tables:
raise ValueError("No HTML tables found in the provided file or URL")
df = tables[0] # Get the first table by default
read_fn = "pd.read_html"
elif mime_type in [
"application/vnd.ms-excel",
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
"application/vnd.oasis.opendocument.spreadsheet",
] or any(file_path_str_lower.endswith(ext) for ext in [".xls", ".xlsx", ".ods"]):
df = pd.read_excel(path_or_url) # opens only sheet 0
read_fn = "pd.read_excel"
elif mime_type == "application/vnd.apache.parquet" or file_path_str_lower.endswith(
".parquet"
): # mime type exists but I did not manage to ever extract it
df = pd.read_parquet(path_or_url)
read_fn = "pd.read_parquet"
else:
raise ValueError("Could not determine file format")
# Check if the result is a Series and convert to DataFrame if needed
if isinstance(df, pd.Series):
df = df.to_frame()
return df, read_fn
|
Load a dataframe based on file format determined by MIME type or file extension.
|
load_dataframe_by_format
|
python
|
mckinsey/vizro
|
vizro-mcp/src/vizro_mcp/_utils/utils.py
|
https://github.com/mckinsey/vizro/blob/master/vizro-mcp/src/vizro_mcp/_utils/utils.py
|
Apache-2.0
|
def path_or_url_check(string: str) -> str:
"""Check if a string is a link or a file path."""
if string.startswith(("http://", "https://", "www.")):
return "remote"
if Path(string).is_file():
return "local"
return "invalid"
|
Check if a string is a link or a file path.
|
path_or_url_check
|
python
|
mckinsey/vizro
|
vizro-mcp/src/vizro_mcp/_utils/utils.py
|
https://github.com/mckinsey/vizro/blob/master/vizro-mcp/src/vizro_mcp/_utils/utils.py
|
Apache-2.0
|
def create_pycafe_url(python_code: str) -> str:
"""Create a PyCafe URL for a given Python code."""
# Create JSON object for py.cafe
json_object = {
"code": python_code,
"requirements": "vizro==0.1.38",
"files": [],
}
# Convert to compressed base64 URL
json_text = json.dumps(json_object)
compressed_json_text = gzip.compress(json_text.encode("utf8"))
base64_text = base64.b64encode(compressed_json_text).decode("utf8")
query = urlencode({"c": base64_text}, quote_via=quote)
pycafe_url = f"{PYCAFE_URL}/snippet/vizro/v1?{query}"
return pycafe_url
|
Create a PyCafe URL for a given Python code.
|
create_pycafe_url
|
python
|
mckinsey/vizro
|
vizro-mcp/src/vizro_mcp/_utils/utils.py
|
https://github.com/mckinsey/vizro/blob/master/vizro-mcp/src/vizro_mcp/_utils/utils.py
|
Apache-2.0
|
def get_python_code_and_preview_link(
model_object: vm.VizroBaseModel, data_infos: list[DFMetaData]
) -> VizroCodeAndPreviewLink:
"""Get the Python code and preview link for a Vizro model object."""
# Get the Python code
python_code = model_object._to_python()
# Add imports after the first empty line
lines = python_code.splitlines()
for i, line in enumerate(lines):
if not line.strip():
# Found first empty line, insert imports here
imports_to_add = [
"from vizro import Vizro",
"import pandas as pd",
"from vizro.managers import data_manager",
]
lines[i:i] = imports_to_add
break
python_code = "\n".join(lines)
# Prepare data loading code
data_loading_code = "\n".join(
f'data_manager["{info.file_name}"] = {info.read_function_string}("{info.file_path_or_url}")'
for info in data_infos
)
# Patterns to identify the data manager section
data_manager_start_marker = "####### Data Manager Settings #####"
data_manager_end_marker = "########### Model code ############"
# Replace everything between the markers with our data loading code
pattern = re.compile(f"{data_manager_start_marker}.*?{data_manager_end_marker}", re.DOTALL)
replacement = f"{data_manager_start_marker}\n{data_loading_code}\n\n{data_manager_end_marker}"
python_code = pattern.sub(replacement, python_code)
# Add final run line
python_code += "\n\nVizro().build(model).run()"
pycafe_url = create_pycafe_url(python_code)
return VizroCodeAndPreviewLink(python_code=python_code, pycafe_url=pycafe_url)
|
Get the Python code and preview link for a Vizro model object.
|
get_python_code_and_preview_link
|
python
|
mckinsey/vizro
|
vizro-mcp/src/vizro_mcp/_utils/utils.py
|
https://github.com/mckinsey/vizro/blob/master/vizro-mcp/src/vizro_mcp/_utils/utils.py
|
Apache-2.0
|
def dashboard_config_validation_result() -> ValidationResults:
"""Fixture for a dashboard configuration validation result."""
return ValidationResults(
valid=True,
message="Configuration is valid for Dashboard!",
python_code="""############ Imports ##############
import vizro.models as vm
from vizro import Vizro
import pandas as pd
from vizro.managers import data_manager
########### Model code ############
model = vm.Dashboard(
pages=[
vm.Page(
id="test_page",
components=[vm.Card(id="test_card", type="card", text="Test content")],
title="Test Page",
)
],
title="Test Dashboard",
)
Vizro().build(model).run()""",
pycafe_url="https://py.cafe/snippet/vizro/v1?c=H4sIAFLGG...",
browser_opened=False,
)
|
Fixture for a dashboard configuration validation result.
|
dashboard_config_validation_result
|
python
|
mckinsey/vizro
|
vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
https://github.com/mckinsey/vizro/blob/master/vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
Apache-2.0
|
def graph_dashboard_config() -> dict[str, Any]:
"""Fixture for a dashboard configuration with a scatter graph."""
return {
"title": "Graph Dashboard",
"pages": [
{
"id": "graph_page",
"title": "Scatter Graph Page",
"components": [
{
"id": "scatter_graph",
"type": "graph",
"figure": {
"_target_": "scatter",
"data_frame": "iris_data",
"x": "sepal_length",
"y": "sepal_width",
"color": "species",
"title": "Iris Scatter Plot",
},
}
],
}
],
}
|
Fixture for a dashboard configuration with a scatter graph.
|
graph_dashboard_config
|
python
|
mckinsey/vizro
|
vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
https://github.com/mckinsey/vizro/blob/master/vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
Apache-2.0
|
def graph_dashboard_validation_result() -> ValidationResults:
"""Fixture for a dashboard configuration with graph validation result."""
return ValidationResults(
valid=True,
message="Configuration is valid for Dashboard!",
python_code="""############ Imports ##############
import vizro.plotly.express as px
import vizro.models as vm
from vizro import Vizro
import pandas as pd
from vizro.managers import data_manager
####### Data Manager Settings #####
data_manager["iris_data"] = pd.read_csv("https://raw.githubusercontent.com/plotly/datasets/master/iris-id.csv")
########### Model code ############
model = vm.Dashboard(
pages=[
vm.Page(
id="graph_page",
components=[
vm.Graph(
id="scatter_graph",
type="graph",
figure=px.scatter(
data_frame="iris_data",
x="sepal_length",
y="sepal_width",
color="species",
title="Iris Scatter Plot",
),
)
],
title="Scatter Graph Page",
)
],
title="Graph Dashboard",
)
Vizro().build(model).run()""",
pycafe_url="https://py.cafe/snippet/vizro/v1?c=example-hash",
browser_opened=False,
)
|
Fixture for a dashboard configuration with graph validation result.
|
graph_dashboard_validation_result
|
python
|
mckinsey/vizro
|
vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
https://github.com/mckinsey/vizro/blob/master/vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
Apache-2.0
|
def invalid_chart_plan() -> dict[str, Any]:
"""Fixture for an invalid chart plan."""
return {
"chart_type": "scatter",
"imports": ["import pandas as pd", "import plotly.express as px"],
"chart_code": """def scatter_chart(data_frame):
return px.scatter(data_frame, x="sepal_length", y="sepal_width", color="species", title="Iris Scatter Plot")""",
}
|
Fixture for an invalid chart plan.
|
invalid_chart_plan
|
python
|
mckinsey/vizro
|
vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
https://github.com/mckinsey/vizro/blob/master/vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
Apache-2.0
|
def chart_plan_validation_result() -> ValidationResults:
"""Fixture for a chart plan validation result."""
return ValidationResults(
valid=True,
message="Chart only dashboard created successfully!",
python_code="""@capture('graph')
def custom_chart(data_frame):
return px.scatter(data_frame, x="sepal_length", y="sepal_width", color="species", title="Iris Scatter Plot")""",
pycafe_url="https://py.cafe/snippet/vizro/v1?c=...",
browser_opened=False,
)
|
Fixture for a chart plan validation result.
|
chart_plan_validation_result
|
python
|
mckinsey/vizro
|
vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
https://github.com/mckinsey/vizro/blob/master/vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
Apache-2.0
|
def test_successful_validation(
self, valid_dashboard_config: dict[str, Any], dashboard_config_validation_result: ValidationResults
) -> None:
"""Test successful validation of a dashboard configuration."""
result = validate_model_config(dashboard_config=valid_dashboard_config, data_infos=[], auto_open=False)
# Compare everything but the pycafe_url
assert result.valid == dashboard_config_validation_result.valid
assert result.message == dashboard_config_validation_result.message
assert result.python_code == dashboard_config_validation_result.python_code
assert result.browser_opened == dashboard_config_validation_result.browser_opened
# For the URL, just check it has the right format
assert result.pycafe_url is not None
assert result.pycafe_url.startswith("https://py.cafe/snippet/vizro/v1?c=")
|
Test successful validation of a dashboard configuration.
|
test_successful_validation
|
python
|
mckinsey/vizro
|
vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
https://github.com/mckinsey/vizro/blob/master/vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
Apache-2.0
|
def test_graph_dashboard_validation(
self,
graph_dashboard_config: dict[str, Any],
graph_dashboard_validation_result: ValidationResults,
iris_metadata: DFMetaData,
) -> None:
"""Test validation of a dashboard with a scatter graph component."""
result = validate_model_config(
dashboard_config=graph_dashboard_config, data_infos=[iris_metadata], auto_open=False
)
# Compare everything but the pycafe_url
assert result.valid == graph_dashboard_validation_result.valid
assert result.message == graph_dashboard_validation_result.message
assert result.python_code == graph_dashboard_validation_result.python_code
assert result.browser_opened == graph_dashboard_validation_result.browser_opened
# For the URL, just check it has the right format
assert result.pycafe_url is not None
assert result.pycafe_url.startswith("https://py.cafe/snippet/vizro/v1?c=")
|
Test validation of a dashboard with a scatter graph component.
|
test_graph_dashboard_validation
|
python
|
mckinsey/vizro
|
vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
https://github.com/mckinsey/vizro/blob/master/vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
Apache-2.0
|
def test_validation_error(self, valid_dashboard_config: dict[str, Any], iris_metadata: DFMetaData) -> None:
"""Test validation error for an invalid dashboard configuration."""
# Create an invalid config by removing a required field
invalid_config = valid_dashboard_config.copy()
invalid_config["titles"] = invalid_config.pop("title")
result = validate_model_config(dashboard_config=invalid_config, data_infos=[iris_metadata], auto_open=False)
assert result.valid is False
assert "Validation Error: 1 validation error for Dashboard" in result.message
assert result.python_code == ""
assert result.pycafe_url is None
assert result.browser_opened is False
|
Test validation error for an invalid dashboard configuration.
|
test_validation_error
|
python
|
mckinsey/vizro
|
vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
https://github.com/mckinsey/vizro/blob/master/vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
Apache-2.0
|
def test_successful_validation(
self,
valid_chart_plan: dict[str, Any],
iris_metadata: DFMetaData,
chart_plan_validation_result: ValidationResults,
) -> None:
"""Test successful validation of chart code."""
result = validate_chart_code(chart_config=valid_chart_plan, data_info=iris_metadata, auto_open=False)
# Compare everything but the pycafe_url
assert result.valid == chart_plan_validation_result.valid
assert result.message == chart_plan_validation_result.message
assert result.python_code == chart_plan_validation_result.python_code
assert result.browser_opened == chart_plan_validation_result.browser_opened
# For the URL, just check it has the right format
assert result.pycafe_url is not None
assert result.pycafe_url.startswith("https://py.cafe/snippet/vizro/v1?c=")
|
Test successful validation of chart code.
|
test_successful_validation
|
python
|
mckinsey/vizro
|
vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
https://github.com/mckinsey/vizro/blob/master/vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
Apache-2.0
|
def test_validation_error(
self,
invalid_chart_plan: dict[str, Any],
iris_metadata: DFMetaData,
) -> None:
"""Test validation error for an invalid chart plan."""
result = validate_chart_code(chart_config=invalid_chart_plan, data_info=iris_metadata, auto_open=False)
assert result.valid is False
assert result.python_code == ""
assert result.pycafe_url is None
assert result.browser_opened is False
assert "Validation Error: 1 validation error for ChartPlan" in result.message
|
Test validation error for an invalid chart plan.
|
test_validation_error
|
python
|
mckinsey/vizro
|
vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
https://github.com/mckinsey/vizro/blob/master/vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
Apache-2.0
|
def test_model_json_schema(self, model_name: str, model_class: type) -> None:
"""Test getting JSON schema for various models."""
schema = get_model_json_schema(model_name=model_name)
# Get the schema directly from the model class
expected_schema = model_class.model_json_schema()
# Compare the schemas
assert schema == expected_schema
|
Test getting JSON schema for various models.
|
test_model_json_schema
|
python
|
mckinsey/vizro
|
vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
https://github.com/mckinsey/vizro/blob/master/vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
Apache-2.0
|
def test_nonexistent_model(self) -> None:
"""Test getting schema for a nonexistent model."""
schema = get_model_json_schema("NonExistentModel")
assert isinstance(schema, dict)
assert "error" in schema
assert "not found" in schema["error"]
|
Test getting schema for a nonexistent model.
|
test_nonexistent_model
|
python
|
mckinsey/vizro
|
vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
https://github.com/mckinsey/vizro/blob/master/vizro-mcp/tests/unit/vizro_mcp/test_server.py
|
Apache-2.0
|
def resnet50_backbone(lda_out_channels, in_chn, pretrained=False, **kwargs):
"""Constructs a ResNet-50 model_hyper.
Args:
pretrained (bool): If True, returns a model_hyper pre-trained on ImageNet
"""
model = ResNetBackbone(lda_out_channels, in_chn, Bottleneck, [3, 4, 6, 3], **kwargs)
if pretrained:
save_model = model_zoo.load_url(model_urls['resnet50'])
model_dict = model.state_dict()
state_dict = {k: v for k, v in save_model.items() if k in model_dict.keys()}
model_dict.update(state_dict)
model.load_state_dict(model_dict)
else:
model.apply(weights_init_xavier)
return model
|
Constructs a ResNet-50 model_hyper.
Args:
pretrained (bool): If True, returns a model_hyper pre-trained on ImageNet
|
resnet50_backbone
|
python
|
bytedance/LatentSync
|
eval/hyper_iqa.py
|
https://github.com/bytedance/LatentSync/blob/master/eval/hyper_iqa.py
|
Apache-2.0
|
def get_random_clip_from_video(self, idx: int) -> tuple:
'''
Sample a random clip starting index from the video.
Args:
idx: Index of the video.
'''
# Note that some videos may not contain enough frames, we skip those videos here.
while self._clips.clips[idx].shape[0] <= 0:
idx += 1
n_clip = self._clips.clips[idx].shape[0]
clip_id = random.randint(0, n_clip - 1)
return idx, clip_id
|
Sample a random clip starting index from the video.
Args:
idx: Index of the video.
|
get_random_clip_from_video
|
python
|
bytedance/LatentSync
|
latentsync/trepa/utils/data_utils.py
|
https://github.com/bytedance/LatentSync/blob/master/latentsync/trepa/utils/data_utils.py
|
Apache-2.0
|
def load_video_frames(self, dataroot: str) -> list:
'''
Loads all the video frames under the dataroot and returns a list of all the video frames.
Args:
dataroot: The root directory containing the video frames.
Returns:
A list of all the video frames.
'''
data_all = []
frame_list = os.walk(dataroot)
for _, meta in enumerate(frame_list):
root = meta[0]
try:
frames = sorted(meta[2], key=lambda item: int(item.split('.')[0].split('_')[-1]))
except:
print(meta[0], meta[2])
if len(frames) < max(0, self.sequence_length * self.sample_every_n_frames):
continue
frames = [
os.path.join(root, item) for item in frames
if is_image_file(item)
]
if len(frames) > max(0, self.sequence_length * self.sample_every_n_frames):
data_all.append(frames)
return data_all
|
Loads all the video frames under the dataroot and returns a list of all the video frames.
Args:
dataroot: The root directory containing the video frames.
Returns:
A list of all the video frames.
|
load_video_frames
|
python
|
bytedance/LatentSync
|
latentsync/trepa/utils/data_utils.py
|
https://github.com/bytedance/LatentSync/blob/master/latentsync/trepa/utils/data_utils.py
|
Apache-2.0
|
def getTensor(self, index: int) -> torch.Tensor:
'''
Returns a tensor of the video frames at the given index.
Args:
index: The index of the video frames to return.
Returns:
A BCTHW tensor in the range `[0, 1]` of the video frames at the given index.
'''
video = self.data_all[index]
video_len = len(video)
# load the entire video when sequence_length = -1, whiel the sample_every_n_frames has to be 1
if self.sequence_length == -1:
assert self.sample_every_n_frames == 1
start_idx = 0
end_idx = video_len
else:
n_frames_interval = self.sequence_length * self.sample_every_n_frames
start_idx = random.randint(0, video_len - n_frames_interval)
end_idx = start_idx + n_frames_interval
img = Image.open(video[0])
h, w = img.height, img.width
if h > w:
half = (h - w) // 2
cropsize = (0, half, w, half + w) # left, upper, right, lower
elif w > h:
half = (w - h) // 2
cropsize = (half, 0, half + h, h)
images = []
for i in range(start_idx, end_idx,
self.sample_every_n_frames):
path = video[i]
img = Image.open(path)
if h != w:
img = img.crop(cropsize)
img = img.resize(
(self.resolution, self.resolution),
Image.ANTIALIAS)
img = np.asarray(img, dtype=np.float32)
img /= 255.
img_tensor = preprocess_image(img).unsqueeze(0)
images.append(img_tensor)
video_clip = torch.cat(images).permute(3, 0, 1, 2)
return video_clip
|
Returns a tensor of the video frames at the given index.
Args:
index: The index of the video frames to return.
Returns:
A BCTHW tensor in the range `[0, 1]` of the video frames at the given index.
|
getTensor
|
python
|
bytedance/LatentSync
|
latentsync/trepa/utils/data_utils.py
|
https://github.com/bytedance/LatentSync/blob/master/latentsync/trepa/utils/data_utils.py
|
Apache-2.0
|
def set_num_features(self, num_features: int):
'''
Set the number of features diminsions.
Args:
num_features: Number of features diminsions.
'''
if self.num_features is not None:
assert num_features == self.num_features
else:
self.num_features = num_features
self.all_features = []
self.raw_mean = np.zeros([num_features], dtype=np.float64)
self.raw_cov = np.zeros([num_features, num_features], dtype=np.float64)
|
Set the number of features diminsions.
Args:
num_features: Number of features diminsions.
|
set_num_features
|
python
|
bytedance/LatentSync
|
latentsync/trepa/utils/metric_utils.py
|
https://github.com/bytedance/LatentSync/blob/master/latentsync/trepa/utils/metric_utils.py
|
Apache-2.0
|
def append(self, x: np.ndarray):
'''
Add the newly computed features to the list. Update the mean and covariance.
Args:
x: New features to record.
'''
x = np.asarray(x, dtype=np.float32)
assert x.ndim == 2
if (self.max_items is not None) and (self.num_items + x.shape[0] > self.max_items):
if self.num_items >= self.max_items:
return
x = x[:self.max_items - self.num_items]
self.set_num_features(x.shape[1])
self.num_items += x.shape[0]
if self.capture_all:
self.all_features.append(x)
if self.capture_mean_cov:
x64 = x.astype(np.float64)
self.raw_mean += x64.sum(axis=0)
self.raw_cov += x64.T @ x64
|
Add the newly computed features to the list. Update the mean and covariance.
Args:
x: New features to record.
|
append
|
python
|
bytedance/LatentSync
|
latentsync/trepa/utils/metric_utils.py
|
https://github.com/bytedance/LatentSync/blob/master/latentsync/trepa/utils/metric_utils.py
|
Apache-2.0
|
def append_torch(self, x: torch.Tensor, rank: int, num_gpus: int):
'''
Add the newly computed PyTorch features to the list. Update the mean and covariance.
Args:
x: New features to record.
rank: Rank of the current GPU.
num_gpus: Total number of GPUs.
'''
assert isinstance(x, torch.Tensor) and x.ndim == 2
assert 0 <= rank < num_gpus
if num_gpus > 1:
ys = []
for src in range(num_gpus):
y = x.clone()
torch.distributed.broadcast(y, src=src)
ys.append(y)
x = torch.stack(ys, dim=1).flatten(0, 1) # interleave samples
self.append(x.cpu().numpy())
|
Add the newly computed PyTorch features to the list. Update the mean and covariance.
Args:
x: New features to record.
rank: Rank of the current GPU.
num_gpus: Total number of GPUs.
|
append_torch
|
python
|
bytedance/LatentSync
|
latentsync/trepa/utils/metric_utils.py
|
https://github.com/bytedance/LatentSync/blob/master/latentsync/trepa/utils/metric_utils.py
|
Apache-2.0
|
def get_all(self) -> np.ndarray:
'''
Get all the stored features as NumPy Array.
Returns:
Concatenation of the stored features.
'''
assert self.capture_all
return np.concatenate(self.all_features, axis=0)
|
Get all the stored features as NumPy Array.
Returns:
Concatenation of the stored features.
|
get_all
|
python
|
bytedance/LatentSync
|
latentsync/trepa/utils/metric_utils.py
|
https://github.com/bytedance/LatentSync/blob/master/latentsync/trepa/utils/metric_utils.py
|
Apache-2.0
|
def get_mean_cov(self) -> Tuple[np.ndarray, np.ndarray]:
'''
Get the mean and covariance of the stored features.
Returns:
Mean and covariance of the stored features.
'''
assert self.capture_mean_cov
mean = self.raw_mean / self.num_items
cov = self.raw_cov / self.num_items
cov = cov - np.outer(mean, mean)
return mean, cov
|
Get the mean and covariance of the stored features.
Returns:
Mean and covariance of the stored features.
|
get_mean_cov
|
python
|
bytedance/LatentSync
|
latentsync/trepa/utils/metric_utils.py
|
https://github.com/bytedance/LatentSync/blob/master/latentsync/trepa/utils/metric_utils.py
|
Apache-2.0
|
def load(pkl_file: str) -> 'FeatureStats':
'''
Load the features and statistics from a pickle file.
Args:
pkl_file: Path to the pickle file.
'''
with open(pkl_file, 'rb') as f:
s = pickle.load(f)
obj = FeatureStats(capture_all=s['capture_all'], max_items=s['max_items'])
obj.__dict__.update(s)
print('Loaded %d features from %s' % (obj.num_items, pkl_file))
return obj
|
Load the features and statistics from a pickle file.
Args:
pkl_file: Path to the pickle file.
|
load
|
python
|
bytedance/LatentSync
|
latentsync/trepa/utils/metric_utils.py
|
https://github.com/bytedance/LatentSync/blob/master/latentsync/trepa/utils/metric_utils.py
|
Apache-2.0
|
def num_frames(length, fsize, fshift):
"""Compute number of time frames of spectrogram"""
pad = fsize - fshift
if length % fshift == 0:
M = (length + pad * 2 - fsize) // fshift + 1
else:
M = (length + pad * 2 - fsize) // fshift + 2
return M
|
Compute number of time frames of spectrogram
|
num_frames
|
python
|
bytedance/LatentSync
|
latentsync/utils/audio.py
|
https://github.com/bytedance/LatentSync/blob/master/latentsync/utils/audio.py
|
Apache-2.0
|
def __getitem__(self, idx):
"""Get audio samples and video frame at `idx`.
Parameters
----------
idx : int or slice
The frame index, can be negative which means it will index backwards,
or slice of frame indices.
Returns
-------
(ndarray/list of ndarray, ndarray)
First element is samples of shape CxS or a list of length N containing samples of shape CxS,
where N is the number of frames, C is the number of channels,
S is the number of samples of the corresponding frame.
Second element is Frame of shape HxWx3 or batch of image frames with shape NxHxWx3,
where N is the length of the slice.
"""
assert self.__video_reader is not None and self.__audio_reader is not None
if isinstance(idx, slice):
return self.get_batch(range(*idx.indices(len(self.__video_reader))))
if idx < 0:
idx += len(self.__video_reader)
if idx >= len(self.__video_reader) or idx < 0:
raise IndexError("Index: {} out of bound: {}".format(idx, len(self.__video_reader)))
audio_start_idx, audio_end_idx = self.__video_reader.get_frame_timestamp(idx)
audio_start_idx = self.__audio_reader._time_to_sample(audio_start_idx)
audio_end_idx = self.__audio_reader._time_to_sample(audio_end_idx)
results = (self.__audio_reader[audio_start_idx:audio_end_idx], self.__video_reader[idx])
self.__video_reader.seek(0)
return results
|
Get audio samples and video frame at `idx`.
Parameters
----------
idx : int or slice
The frame index, can be negative which means it will index backwards,
or slice of frame indices.
Returns
-------
(ndarray/list of ndarray, ndarray)
First element is samples of shape CxS or a list of length N containing samples of shape CxS,
where N is the number of frames, C is the number of channels,
S is the number of samples of the corresponding frame.
Second element is Frame of shape HxWx3 or batch of image frames with shape NxHxWx3,
where N is the length of the slice.
|
__getitem__
|
python
|
bytedance/LatentSync
|
latentsync/utils/av_reader.py
|
https://github.com/bytedance/LatentSync/blob/master/latentsync/utils/av_reader.py
|
Apache-2.0
|
def get_batch(self, indices):
"""Get entire batch of audio samples and video frames.
Parameters
----------
indices : list of integers
A list of frame indices. If negative indices detected, the indices will be indexed from backward
Returns
-------
(list of ndarray, ndarray)
First element is a list of length N containing samples of shape CxS,
where N is the number of frames, C is the number of channels,
S is the number of samples of the corresponding frame.
Second element is Frame of shape HxWx3 or batch of image frames with shape NxHxWx3,
where N is the length of the slice.
"""
assert self.__video_reader is not None and self.__audio_reader is not None
indices = self._validate_indices(indices)
audio_arr = []
prev_video_idx = None
prev_audio_end_idx = None
for idx in list(indices):
frame_start_time, frame_end_time = self.__video_reader.get_frame_timestamp(idx)
# timestamp and sample conversion could have some error that could cause non-continuous audio
# we detect if retrieving continuous frame and make the audio continuous
if prev_video_idx and idx == prev_video_idx + 1:
audio_start_idx = prev_audio_end_idx
else:
audio_start_idx = self.__audio_reader._time_to_sample(frame_start_time)
audio_end_idx = self.__audio_reader._time_to_sample(frame_end_time)
audio_arr.append(self.__audio_reader[audio_start_idx:audio_end_idx])
prev_video_idx = idx
prev_audio_end_idx = audio_end_idx
results = (audio_arr, self.__video_reader.get_batch(indices))
self.__video_reader.seek(0)
return results
|
Get entire batch of audio samples and video frames.
Parameters
----------
indices : list of integers
A list of frame indices. If negative indices detected, the indices will be indexed from backward
Returns
-------
(list of ndarray, ndarray)
First element is a list of length N containing samples of shape CxS,
where N is the number of frames, C is the number of channels,
S is the number of samples of the corresponding frame.
Second element is Frame of shape HxWx3 or batch of image frames with shape NxHxWx3,
where N is the length of the slice.
|
get_batch
|
python
|
bytedance/LatentSync
|
latentsync/utils/av_reader.py
|
https://github.com/bytedance/LatentSync/blob/master/latentsync/utils/av_reader.py
|
Apache-2.0
|
def _validate_indices(self, indices):
"""Validate int64 integers and convert negative integers to positive by backward search"""
assert self.__video_reader is not None and self.__audio_reader is not None
indices = np.array(indices, dtype=np.int64)
# process negative indices
indices[indices < 0] += len(self.__video_reader)
if not (indices >= 0).all():
raise IndexError("Invalid negative indices: {}".format(indices[indices < 0] + len(self.__video_reader)))
if not (indices < len(self.__video_reader)).all():
raise IndexError("Out of bound indices: {}".format(indices[indices >= len(self.__video_reader)]))
return indices
|
Validate int64 integers and convert negative integers to positive by backward search
|
_validate_indices
|
python
|
bytedance/LatentSync
|
latentsync/utils/av_reader.py
|
https://github.com/bytedance/LatentSync/blob/master/latentsync/utils/av_reader.py
|
Apache-2.0
|
def cuda_to_int(cuda_str: str) -> int:
"""
Convert the string with format "cuda:X" to integer X.
"""
if cuda_str == "cuda":
return 0
device = torch.device(cuda_str)
if device.type != "cuda":
raise ValueError(f"Device type must be 'cuda', got: {device.type}")
return device.index
|
Convert the string with format "cuda:X" to integer X.
|
cuda_to_int
|
python
|
bytedance/LatentSync
|
latentsync/utils/face_detector.py
|
https://github.com/bytedance/LatentSync/blob/master/latentsync/utils/face_detector.py
|
Apache-2.0
|
def get_sliced_feature(self, feature_array, vid_idx, fps=25):
"""
Get sliced features based on a given index
:param feature_array:
:param start_idx: the start index of the feature
:param audio_feat_length:
:return:
"""
length = len(feature_array)
selected_feature = []
selected_idx = []
center_idx = int(vid_idx * 50 / fps)
left_idx = center_idx - self.audio_feat_length[0] * 2
right_idx = center_idx + (self.audio_feat_length[1] + 1) * 2
for idx in range(left_idx, right_idx):
idx = max(0, idx)
idx = min(length - 1, idx)
x = feature_array[idx]
selected_feature.append(x)
selected_idx.append(idx)
selected_feature = torch.cat(selected_feature, dim=0)
selected_feature = selected_feature.reshape(-1, self.embedding_dim) # 50*384
return selected_feature, selected_idx
|
Get sliced features based on a given index
:param feature_array:
:param start_idx: the start index of the feature
:param audio_feat_length:
:return:
|
get_sliced_feature
|
python
|
bytedance/LatentSync
|
latentsync/whisper/audio2feature.py
|
https://github.com/bytedance/LatentSync/blob/master/latentsync/whisper/audio2feature.py
|
Apache-2.0
|
def cpg():
"""
>>> # +--------------+-----------+-----------+-----------+
>>> # | Chromosome | Start | End | CpG |
>>> # | (category) | (int64) | (int64) | (int64) |
>>> # |--------------+-----------+-----------+-----------|
>>> # | chrX | 64181 | 64793 | 62 |
>>> # | chrX | 69133 | 70029 | 100 |
>>> # | chrX | 148685 | 149461 | 85 |
>>> # | chrX | 166504 | 167721 | 96 |
>>> # | ... | ... | ... | ... |
>>> # | chrY | 28555535 | 28555932 | 32 |
>>> # | chrY | 28773315 | 28773544 | 25 |
>>> # | chrY | 59213794 | 59214183 | 36 |
>>> # | chrY | 59349266 | 59349574 | 29 |
>>> # +--------------+-----------+-----------+-----------+
>>> # Unstranded PyRanges object has 1,077 rows and 4 columns from 2 chromosomes.
>>> # For printing, the PyRanges was sorted on Chromosome.
"""
full_path = get_example_path("cpg.bed")
df = pd.read_csv(full_path, sep="\t", header=None, names="Chromosome Start End CpG".split())
return pr.PyRanges(df)
|
>>> # +--------------+-----------+-----------+-----------+
>>> # | Chromosome | Start | End | CpG |
>>> # | (category) | (int64) | (int64) | (int64) |
>>> # |--------------+-----------+-----------+-----------|
>>> # | chrX | 64181 | 64793 | 62 |
>>> # | chrX | 69133 | 70029 | 100 |
>>> # | chrX | 148685 | 149461 | 85 |
>>> # | chrX | 166504 | 167721 | 96 |
>>> # | ... | ... | ... | ... |
>>> # | chrY | 28555535 | 28555932 | 32 |
>>> # | chrY | 28773315 | 28773544 | 25 |
>>> # | chrY | 59213794 | 59214183 | 36 |
>>> # | chrY | 59349266 | 59349574 | 29 |
>>> # +--------------+-----------+-----------+-----------+
>>> # Unstranded PyRanges object has 1,077 rows and 4 columns from 2 chromosomes.
>>> # For printing, the PyRanges was sorted on Chromosome.
|
cpg
|
python
|
pyranges/pyranges
|
pyranges/data.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/data.py
|
MIT
|
def ucsc_bed():
"""
>>> # +--------------+-----------+-----------+------------+------------+-----------------+--------------+---------------+-------------------+
>>> # | Chromosome | Start | End | Feature | gene_id | transcript_id | Strand | exon_number | transcript_name |
>>> # | (category) | (int64) | (int64) | (object) | (object) | (float64) | (category) | (float64) | (object) |
>>> # |--------------+-----------+-----------+------------+------------+-----------------+--------------+---------------+-------------------|
>>> # | chr1 | 12776117 | 12788726 | gene | AADACL3 | nan | + | nan | nan |
>>> # | chr1 | 169075927 | 169101957 | gene | ATP1B1 | nan | + | nan | nan |
>>> # | chr1 | 6845383 | 7829766 | gene | CAMTA1 | nan | + | nan | nan |
>>> # | chr1 | 20915589 | 20945396 | gene | CDA | nan | + | nan | nan |
>>> # | ... | ... | ... | ... | ... | ... | ... | ... | ... |
>>> # | chrX | 152661096 | 152663330 | exon | PNMA6E | 260.0 | - | 0.0 | NM_001351293 |
>>> # | chrX | 152661096 | 152666808 | transcript | PNMA6E | 260.0 | - | nan | NM_001351293 |
>>> # | chrX | 152664164 | 152664378 | exon | PNMA6E | 260.0 | - | 1.0 | NM_001351293 |
>>> # | chrX | 152666701 | 152666808 | exon | PNMA6E | 260.0 | - | 2.0 | NM_001351293 |
>>> # +--------------+-----------+-----------+------------+------------+-----------------+--------------+---------------+-------------------+
>>> # Stranded PyRanges object has 5,519 rows and 9 columns from 30 chromosomes.
>>> # For printing, the PyRanges was sorted on Chromosome and Strand.
"""
full_path = get_example_path("ucsc_human.bed.gz")
names = "Chromosome Start End Feature gene_id transcript_id Strand exon_number transcript_name".split()
df = pd.read_csv(full_path, sep="\t", names=names)
return pr.PyRanges(df)
|
>>> # +--------------+-----------+-----------+------------+------------+-----------------+--------------+---------------+-------------------+
>>> # | Chromosome | Start | End | Feature | gene_id | transcript_id | Strand | exon_number | transcript_name |
>>> # | (category) | (int64) | (int64) | (object) | (object) | (float64) | (category) | (float64) | (object) |
>>> # |--------------+-----------+-----------+------------+------------+-----------------+--------------+---------------+-------------------|
>>> # | chr1 | 12776117 | 12788726 | gene | AADACL3 | nan | + | nan | nan |
>>> # | chr1 | 169075927 | 169101957 | gene | ATP1B1 | nan | + | nan | nan |
>>> # | chr1 | 6845383 | 7829766 | gene | CAMTA1 | nan | + | nan | nan |
>>> # | chr1 | 20915589 | 20945396 | gene | CDA | nan | + | nan | nan |
>>> # | ... | ... | ... | ... | ... | ... | ... | ... | ... |
>>> # | chrX | 152661096 | 152663330 | exon | PNMA6E | 260.0 | - | 0.0 | NM_001351293 |
>>> # | chrX | 152661096 | 152666808 | transcript | PNMA6E | 260.0 | - | nan | NM_001351293 |
>>> # | chrX | 152664164 | 152664378 | exon | PNMA6E | 260.0 | - | 1.0 | NM_001351293 |
>>> # | chrX | 152666701 | 152666808 | exon | PNMA6E | 260.0 | - | 2.0 | NM_001351293 |
>>> # +--------------+-----------+-----------+------------+------------+-----------------+--------------+---------------+-------------------+
>>> # Stranded PyRanges object has 5,519 rows and 9 columns from 30 chromosomes.
>>> # For printing, the PyRanges was sorted on Chromosome and Strand.
|
ucsc_bed
|
python
|
pyranges/pyranges
|
pyranges/data.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/data.py
|
MIT
|
def tss(self):
"""Return the transcription start sites.
Returns the 5' for every interval with feature "transcript".
See Also
--------
pyranges.genomicfeatures.GenomicFeaturesMethods.tes : return the transcription end sites
Examples
--------
>>> gr = pr.data.ensembl_gtf()[["Source", "Feature"]]
>>> gr
+--------------+------------+--------------+-----------+-----------+--------------+
| Chromosome | Source | Feature | Start | End | Strand |
| (category) | (object) | (category) | (int64) | (int64) | (category) |
|--------------+------------+--------------+-----------+-----------+--------------|
| 1 | havana | gene | 11868 | 14409 | + |
| 1 | havana | transcript | 11868 | 14409 | + |
| 1 | havana | exon | 11868 | 12227 | + |
| 1 | havana | exon | 12612 | 12721 | + |
| ... | ... | ... | ... | ... | ... |
| 1 | havana | gene | 1173055 | 1179555 | - |
| 1 | havana | transcript | 1173055 | 1179555 | - |
| 1 | havana | exon | 1179364 | 1179555 | - |
| 1 | havana | exon | 1173055 | 1176396 | - |
+--------------+------------+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2,446 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.features.tss()
+--------------+------------+------------+-----------+-----------+--------------+
| Chromosome | Source | Feature | Start | End | Strand |
| (category) | (object) | (object) | (int64) | (int64) | (category) |
|--------------+------------+------------+-----------+-----------+--------------|
| 1 | havana | tss | 11868 | 11869 | + |
| 1 | havana | tss | 12009 | 12010 | + |
| 1 | havana | tss | 29553 | 29554 | + |
| 1 | havana | tss | 30266 | 30267 | + |
| ... | ... | ... | ... | ... | ... |
| 1 | havana | tss | 1092812 | 1092813 | - |
| 1 | havana | tss | 1116086 | 1116087 | - |
| 1 | havana | tss | 1116088 | 1116089 | - |
| 1 | havana | tss | 1179554 | 1179555 | - |
+--------------+------------+------------+-----------+-----------+--------------+
Stranded PyRanges object has 280 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
pr = self.pr
if not pr.stranded:
raise Exception(
"Cannot compute TSSes or TESes without strand info. Perhaps use extend() or subsequence() or spliced_subsequence() instead?"
)
pr = pr[pr.Feature == "transcript"]
pr = pr.apply(lambda df: _tss(df))
pr.Feature = "tss"
return pr
|
Return the transcription start sites.
Returns the 5' for every interval with feature "transcript".
See Also
--------
pyranges.genomicfeatures.GenomicFeaturesMethods.tes : return the transcription end sites
Examples
--------
>>> gr = pr.data.ensembl_gtf()[["Source", "Feature"]]
>>> gr
+--------------+------------+--------------+-----------+-----------+--------------+
| Chromosome | Source | Feature | Start | End | Strand |
| (category) | (object) | (category) | (int64) | (int64) | (category) |
|--------------+------------+--------------+-----------+-----------+--------------|
| 1 | havana | gene | 11868 | 14409 | + |
| 1 | havana | transcript | 11868 | 14409 | + |
| 1 | havana | exon | 11868 | 12227 | + |
| 1 | havana | exon | 12612 | 12721 | + |
| ... | ... | ... | ... | ... | ... |
| 1 | havana | gene | 1173055 | 1179555 | - |
| 1 | havana | transcript | 1173055 | 1179555 | - |
| 1 | havana | exon | 1179364 | 1179555 | - |
| 1 | havana | exon | 1173055 | 1176396 | - |
+--------------+------------+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2,446 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.features.tss()
+--------------+------------+------------+-----------+-----------+--------------+
| Chromosome | Source | Feature | Start | End | Strand |
| (category) | (object) | (object) | (int64) | (int64) | (category) |
|--------------+------------+------------+-----------+-----------+--------------|
| 1 | havana | tss | 11868 | 11869 | + |
| 1 | havana | tss | 12009 | 12010 | + |
| 1 | havana | tss | 29553 | 29554 | + |
| 1 | havana | tss | 30266 | 30267 | + |
| ... | ... | ... | ... | ... | ... |
| 1 | havana | tss | 1092812 | 1092813 | - |
| 1 | havana | tss | 1116086 | 1116087 | - |
| 1 | havana | tss | 1116088 | 1116089 | - |
| 1 | havana | tss | 1179554 | 1179555 | - |
+--------------+------------+------------+-----------+-----------+--------------+
Stranded PyRanges object has 280 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
tss
|
python
|
pyranges/pyranges
|
pyranges/genomicfeatures.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/genomicfeatures.py
|
MIT
|
def tes(self, slack=0):
"""Return the transcription end sites.
Returns the 3' for every interval with feature "transcript".
See Also
--------
pyranges.genomicfeatures.GenomicFeaturesMethods.tss : return the transcription start sites
Examples
--------
>>> gr = pr.data.ensembl_gtf()[["Source", "Feature"]]
>>> gr
+--------------+------------+--------------+-----------+-----------+--------------+
| Chromosome | Source | Feature | Start | End | Strand |
| (category) | (object) | (category) | (int64) | (int64) | (category) |
|--------------+------------+--------------+-----------+-----------+--------------|
| 1 | havana | gene | 11868 | 14409 | + |
| 1 | havana | transcript | 11868 | 14409 | + |
| 1 | havana | exon | 11868 | 12227 | + |
| 1 | havana | exon | 12612 | 12721 | + |
| ... | ... | ... | ... | ... | ... |
| 1 | havana | gene | 1173055 | 1179555 | - |
| 1 | havana | transcript | 1173055 | 1179555 | - |
| 1 | havana | exon | 1179364 | 1179555 | - |
| 1 | havana | exon | 1173055 | 1176396 | - |
+--------------+------------+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2,446 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.features.tes()
+--------------+------------+------------+-----------+-----------+--------------+
| Chromosome | Source | Feature | Start | End | Strand |
| (category) | (object) | (object) | (int64) | (int64) | (category) |
|--------------+------------+------------+-----------+-----------+--------------|
| 1 | havana | tes | 14408 | 14409 | + |
| 1 | havana | tes | 13669 | 13670 | + |
| 1 | havana | tes | 31096 | 31097 | + |
| 1 | havana | tes | 31108 | 31109 | + |
| ... | ... | ... | ... | ... | ... |
| 1 | havana | tes | 1090405 | 1090406 | - |
| 1 | havana | tes | 1091045 | 1091046 | - |
| 1 | havana | tes | 1091499 | 1091500 | - |
| 1 | havana | tes | 1173055 | 1173056 | - |
+--------------+------------+------------+-----------+-----------+--------------+
Stranded PyRanges object has 280 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
pr = self.pr
if not pr.stranded:
raise Exception(
"Cannot compute TSSes or TESes without strand info. Perhaps use extend() or subsequence() or spliced_subsequence() instead?"
)
pr = pr[pr.Feature == "transcript"]
pr = pr.apply(lambda df: _tes(df))
pr.Feature = "tes"
return pr
|
Return the transcription end sites.
Returns the 3' for every interval with feature "transcript".
See Also
--------
pyranges.genomicfeatures.GenomicFeaturesMethods.tss : return the transcription start sites
Examples
--------
>>> gr = pr.data.ensembl_gtf()[["Source", "Feature"]]
>>> gr
+--------------+------------+--------------+-----------+-----------+--------------+
| Chromosome | Source | Feature | Start | End | Strand |
| (category) | (object) | (category) | (int64) | (int64) | (category) |
|--------------+------------+--------------+-----------+-----------+--------------|
| 1 | havana | gene | 11868 | 14409 | + |
| 1 | havana | transcript | 11868 | 14409 | + |
| 1 | havana | exon | 11868 | 12227 | + |
| 1 | havana | exon | 12612 | 12721 | + |
| ... | ... | ... | ... | ... | ... |
| 1 | havana | gene | 1173055 | 1179555 | - |
| 1 | havana | transcript | 1173055 | 1179555 | - |
| 1 | havana | exon | 1179364 | 1179555 | - |
| 1 | havana | exon | 1173055 | 1176396 | - |
+--------------+------------+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2,446 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.features.tes()
+--------------+------------+------------+-----------+-----------+--------------+
| Chromosome | Source | Feature | Start | End | Strand |
| (category) | (object) | (object) | (int64) | (int64) | (category) |
|--------------+------------+------------+-----------+-----------+--------------|
| 1 | havana | tes | 14408 | 14409 | + |
| 1 | havana | tes | 13669 | 13670 | + |
| 1 | havana | tes | 31096 | 31097 | + |
| 1 | havana | tes | 31108 | 31109 | + |
| ... | ... | ... | ... | ... | ... |
| 1 | havana | tes | 1090405 | 1090406 | - |
| 1 | havana | tes | 1091045 | 1091046 | - |
| 1 | havana | tes | 1091499 | 1091500 | - |
| 1 | havana | tes | 1173055 | 1173056 | - |
+--------------+------------+------------+-----------+-----------+--------------+
Stranded PyRanges object has 280 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
tes
|
python
|
pyranges/pyranges
|
pyranges/genomicfeatures.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/genomicfeatures.py
|
MIT
|
def introns(self, by="gene", nb_cpu=1):
"""Return the introns.
Parameters
----------
by : str, {"gene", "transcript"}, default "gene"
Whether to find introns per gene or transcript.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
See Also
--------
pyranges.genomicfeatures.GenomicFeaturesMethods.tss : return the transcription start sites
Examples
--------
>>> gr = pr.data.ensembl_gtf()[["Feature", "gene_id", "transcript_id"]]
>>> gr
+--------------+--------------+-----------+-----------+--------------+-----------------+-----------------+
| Chromosome | Feature | Start | End | Strand | gene_id | transcript_id |
| (category) | (category) | (int64) | (int64) | (category) | (object) | (object) |
|--------------+--------------+-----------+-----------+--------------+-----------------+-----------------|
| 1 | gene | 11868 | 14409 | + | ENSG00000223972 | nan |
| 1 | transcript | 11868 | 14409 | + | ENSG00000223972 | ENST00000456328 |
| 1 | exon | 11868 | 12227 | + | ENSG00000223972 | ENST00000456328 |
| 1 | exon | 12612 | 12721 | + | ENSG00000223972 | ENST00000456328 |
| ... | ... | ... | ... | ... | ... | ... |
| 1 | gene | 1173055 | 1179555 | - | ENSG00000205231 | nan |
| 1 | transcript | 1173055 | 1179555 | - | ENSG00000205231 | ENST00000379317 |
| 1 | exon | 1179364 | 1179555 | - | ENSG00000205231 | ENST00000379317 |
| 1 | exon | 1173055 | 1176396 | - | ENSG00000205231 | ENST00000379317 |
+--------------+--------------+-----------+-----------+--------------+-----------------+-----------------+
Stranded PyRanges object has 2,446 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.features.introns(by="gene")
+--------------+------------+-----------+-----------+--------------+-----------------+-----------------+
| Chromosome | Feature | Start | End | Strand | gene_id | transcript_id |
| (object) | (object) | (int64) | (int64) | (category) | (object) | (object) |
|--------------+------------+-----------+-----------+--------------+-----------------+-----------------|
| 1 | intron | 1173926 | 1174265 | + | ENSG00000162571 | nan |
| 1 | intron | 1174321 | 1174423 | + | ENSG00000162571 | nan |
| 1 | intron | 1174489 | 1174520 | + | ENSG00000162571 | nan |
| 1 | intron | 1175034 | 1179188 | + | ENSG00000162571 | nan |
| ... | ... | ... | ... | ... | ... | ... |
| 1 | intron | 874591 | 875046 | - | ENSG00000283040 | nan |
| 1 | intron | 875155 | 875525 | - | ENSG00000283040 | nan |
| 1 | intron | 875625 | 876526 | - | ENSG00000283040 | nan |
| 1 | intron | 876611 | 876754 | - | ENSG00000283040 | nan |
+--------------+------------+-----------+-----------+--------------+-----------------+-----------------+
Stranded PyRanges object has 311 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.features.introns(by="transcript")
+--------------+------------+-----------+-----------+--------------+-----------------+-----------------+
| Chromosome | Feature | Start | End | Strand | gene_id | transcript_id |
| (object) | (object) | (int64) | (int64) | (category) | (object) | (object) |
|--------------+------------+-----------+-----------+--------------+-----------------+-----------------|
| 1 | intron | 818202 | 818722 | + | ENSG00000177757 | ENST00000326734 |
| 1 | intron | 960800 | 961292 | + | ENSG00000187961 | ENST00000338591 |
| 1 | intron | 961552 | 961628 | + | ENSG00000187961 | ENST00000338591 |
| 1 | intron | 961750 | 961825 | + | ENSG00000187961 | ENST00000338591 |
| ... | ... | ... | ... | ... | ... | ... |
| 1 | intron | 732207 | 732980 | - | ENSG00000230021 | ENST00000648019 |
| 1 | intron | 168165 | 169048 | - | ENSG00000241860 | ENST00000655252 |
| 1 | intron | 165942 | 167958 | - | ENSG00000241860 | ENST00000662089 |
| 1 | intron | 168165 | 169048 | - | ENSG00000241860 | ENST00000662089 |
+--------------+------------+-----------+-----------+--------------+-----------------+-----------------+
Stranded PyRanges object has 1,043 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
kwargs = {"by": by, "nb_cpu": nb_cpu}
kwargs = pr.pyranges_main.fill_kwargs(kwargs)
assert by in ["gene", "transcript"]
id_column = by_to_id[by]
gr = self.pr.sort(id_column)
if not len(gr):
return pr.PyRanges()
exons = gr.subset(lambda df: df.Feature == "exon")
exons = exons.merge(by=id_column)
by_gr = gr.subset(lambda df: df.Feature == by)
result = pyrange_apply(_introns2, by_gr, exons, **kwargs)
return pr.PyRanges(result)
|
Return the introns.
Parameters
----------
by : str, {"gene", "transcript"}, default "gene"
Whether to find introns per gene or transcript.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
See Also
--------
pyranges.genomicfeatures.GenomicFeaturesMethods.tss : return the transcription start sites
Examples
--------
>>> gr = pr.data.ensembl_gtf()[["Feature", "gene_id", "transcript_id"]]
>>> gr
+--------------+--------------+-----------+-----------+--------------+-----------------+-----------------+
| Chromosome | Feature | Start | End | Strand | gene_id | transcript_id |
| (category) | (category) | (int64) | (int64) | (category) | (object) | (object) |
|--------------+--------------+-----------+-----------+--------------+-----------------+-----------------|
| 1 | gene | 11868 | 14409 | + | ENSG00000223972 | nan |
| 1 | transcript | 11868 | 14409 | + | ENSG00000223972 | ENST00000456328 |
| 1 | exon | 11868 | 12227 | + | ENSG00000223972 | ENST00000456328 |
| 1 | exon | 12612 | 12721 | + | ENSG00000223972 | ENST00000456328 |
| ... | ... | ... | ... | ... | ... | ... |
| 1 | gene | 1173055 | 1179555 | - | ENSG00000205231 | nan |
| 1 | transcript | 1173055 | 1179555 | - | ENSG00000205231 | ENST00000379317 |
| 1 | exon | 1179364 | 1179555 | - | ENSG00000205231 | ENST00000379317 |
| 1 | exon | 1173055 | 1176396 | - | ENSG00000205231 | ENST00000379317 |
+--------------+--------------+-----------+-----------+--------------+-----------------+-----------------+
Stranded PyRanges object has 2,446 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.features.introns(by="gene")
+--------------+------------+-----------+-----------+--------------+-----------------+-----------------+
| Chromosome | Feature | Start | End | Strand | gene_id | transcript_id |
| (object) | (object) | (int64) | (int64) | (category) | (object) | (object) |
|--------------+------------+-----------+-----------+--------------+-----------------+-----------------|
| 1 | intron | 1173926 | 1174265 | + | ENSG00000162571 | nan |
| 1 | intron | 1174321 | 1174423 | + | ENSG00000162571 | nan |
| 1 | intron | 1174489 | 1174520 | + | ENSG00000162571 | nan |
| 1 | intron | 1175034 | 1179188 | + | ENSG00000162571 | nan |
| ... | ... | ... | ... | ... | ... | ... |
| 1 | intron | 874591 | 875046 | - | ENSG00000283040 | nan |
| 1 | intron | 875155 | 875525 | - | ENSG00000283040 | nan |
| 1 | intron | 875625 | 876526 | - | ENSG00000283040 | nan |
| 1 | intron | 876611 | 876754 | - | ENSG00000283040 | nan |
+--------------+------------+-----------+-----------+--------------+-----------------+-----------------+
Stranded PyRanges object has 311 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.features.introns(by="transcript")
+--------------+------------+-----------+-----------+--------------+-----------------+-----------------+
| Chromosome | Feature | Start | End | Strand | gene_id | transcript_id |
| (object) | (object) | (int64) | (int64) | (category) | (object) | (object) |
|--------------+------------+-----------+-----------+--------------+-----------------+-----------------|
| 1 | intron | 818202 | 818722 | + | ENSG00000177757 | ENST00000326734 |
| 1 | intron | 960800 | 961292 | + | ENSG00000187961 | ENST00000338591 |
| 1 | intron | 961552 | 961628 | + | ENSG00000187961 | ENST00000338591 |
| 1 | intron | 961750 | 961825 | + | ENSG00000187961 | ENST00000338591 |
| ... | ... | ... | ... | ... | ... | ... |
| 1 | intron | 732207 | 732980 | - | ENSG00000230021 | ENST00000648019 |
| 1 | intron | 168165 | 169048 | - | ENSG00000241860 | ENST00000655252 |
| 1 | intron | 165942 | 167958 | - | ENSG00000241860 | ENST00000662089 |
| 1 | intron | 168165 | 169048 | - | ENSG00000241860 | ENST00000662089 |
+--------------+------------+-----------+-----------+--------------+-----------------+-----------------+
Stranded PyRanges object has 1,043 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
introns
|
python
|
pyranges/pyranges
|
pyranges/genomicfeatures.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/genomicfeatures.py
|
MIT
|
def genome_bounds(gr, chromsizes, clip=False, only_right=False):
"""Remove or clip intervals outside of genome bounds.
Parameters
----------
gr : PyRanges
Input intervals
chromsizes : dict or PyRanges or pyfaidx.Fasta
Dict or PyRanges describing the lengths of the chromosomes.
pyfaidx.Fasta object is also accepted since it conveniently loads chromosome length
clip : bool, default False
Returns the portions of intervals within bounds,
instead of dropping intervals entirely if they are even partially
out of bounds
only_right : bool, default False
If True, remove or clip only intervals that are out-of-bounds on the right,
and do not alter those out-of-bounds on the left (whose Start is < 0)
Examples
--------
>>> d = {"Chromosome": [1, 1, 3], "Start": [1, 249250600, 5], "End": [2, 249250640, 7]}
>>> gr = pr.from_dict(d)
>>> gr
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| 1 | 1 | 2 |
| 1 | 249250600 | 249250640 |
| 3 | 5 | 7 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 2 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> chromsizes = {"1": 249250621, "3": 500}
>>> chromsizes
{'1': 249250621, '3': 500}
>>> pr.gf.genome_bounds(gr, chromsizes)
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| 1 | 1 | 2 |
| 3 | 5 | 7 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 3 columns from 2 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> pr.gf.genome_bounds(gr, chromsizes, clip=True)
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| 1 | 1 | 2 |
| 1 | 249250600 | 249250621 |
| 3 | 5 | 7 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 2 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> del chromsizes['3']
>>> chromsizes
{'1': 249250621}
>>> pr.gf.genome_bounds(gr, chromsizes)
Traceback (most recent call last):
...
KeyError: '3'
"""
if isinstance(chromsizes, pr.PyRanges):
chromsizes = {k: v for k, v in zip(chromsizes.Chromosome, chromsizes.End)}
elif isinstance(chromsizes, dict):
pass
else:
try:
import pyfaidx # type: ignore
if isinstance(chromsizes, pyfaidx.Fasta):
chromsizes = {k: len(chromsizes[k]) for k in chromsizes.keys()}
except ImportError:
pass
assert isinstance(
chromsizes, dict
), "ERROR chromsizes must be a dictionary, or a PyRanges, or a pyfaidx.Fasta object"
return gr.apply(_outside_bounds, chromsizes=chromsizes, clip=clip, only_right=only_right)
|
Remove or clip intervals outside of genome bounds.
Parameters
----------
gr : PyRanges
Input intervals
chromsizes : dict or PyRanges or pyfaidx.Fasta
Dict or PyRanges describing the lengths of the chromosomes.
pyfaidx.Fasta object is also accepted since it conveniently loads chromosome length
clip : bool, default False
Returns the portions of intervals within bounds,
instead of dropping intervals entirely if they are even partially
out of bounds
only_right : bool, default False
If True, remove or clip only intervals that are out-of-bounds on the right,
and do not alter those out-of-bounds on the left (whose Start is < 0)
Examples
--------
>>> d = {"Chromosome": [1, 1, 3], "Start": [1, 249250600, 5], "End": [2, 249250640, 7]}
>>> gr = pr.from_dict(d)
>>> gr
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| 1 | 1 | 2 |
| 1 | 249250600 | 249250640 |
| 3 | 5 | 7 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 2 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> chromsizes = {"1": 249250621, "3": 500}
>>> chromsizes
{'1': 249250621, '3': 500}
>>> pr.gf.genome_bounds(gr, chromsizes)
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| 1 | 1 | 2 |
| 3 | 5 | 7 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 3 columns from 2 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> pr.gf.genome_bounds(gr, chromsizes, clip=True)
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| 1 | 1 | 2 |
| 1 | 249250600 | 249250621 |
| 3 | 5 | 7 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 2 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> del chromsizes['3']
>>> chromsizes
{'1': 249250621}
>>> pr.gf.genome_bounds(gr, chromsizes)
Traceback (most recent call last):
...
KeyError: '3'
|
genome_bounds
|
python
|
pyranges/pyranges
|
pyranges/genomicfeatures.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/genomicfeatures.py
|
MIT
|
def tile_genome(genome, tile_size, tile_last=False):
"""Create a tiled genome.
Parameters
----------
chromsizes : dict or PyRanges
Dict or PyRanges describing the lengths of the chromosomes.
tile_size : int
Length of the tiles.
tile_last : bool, default False
Use genome length as end of last tile.
See Also
--------
pyranges.PyRanges.tile : split intervals into adjacent non-overlapping tiles.
Examples
--------
>>> chromsizes = pr.data.chromsizes()
>>> chromsizes
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 0 | 249250621 |
| chr2 | 0 | 243199373 |
| chr3 | 0 | 198022430 |
| chr4 | 0 | 191154276 |
| ... | ... | ... |
| chr22 | 0 | 51304566 |
| chrM | 0 | 16571 |
| chrX | 0 | 155270560 |
| chrY | 0 | 59373566 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 25 rows and 3 columns from 25 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> pr.gf.tile_genome(chromsizes, int(1e6))
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 0 | 1000000 |
| chr1 | 1000000 | 2000000 |
| chr1 | 2000000 | 3000000 |
| chr1 | 3000000 | 4000000 |
| ... | ... | ... |
| chrY | 56000000 | 57000000 |
| chrY | 57000000 | 58000000 |
| chrY | 58000000 | 59000000 |
| chrY | 59000000 | 59373566 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3,114 rows and 3 columns from 25 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
"""
if isinstance(genome, dict):
chromosomes, ends = list(genome.keys()), list(genome.values())
df = pd.DataFrame({"Chromosome": chromosomes, "Start": 0, "End": ends})
genome = pr.PyRanges(df)
gr = genome.tile(tile_size)
if not tile_last:
gr = gr.apply(_last_tile, sizes=genome)
return gr
|
Create a tiled genome.
Parameters
----------
chromsizes : dict or PyRanges
Dict or PyRanges describing the lengths of the chromosomes.
tile_size : int
Length of the tiles.
tile_last : bool, default False
Use genome length as end of last tile.
See Also
--------
pyranges.PyRanges.tile : split intervals into adjacent non-overlapping tiles.
Examples
--------
>>> chromsizes = pr.data.chromsizes()
>>> chromsizes
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 0 | 249250621 |
| chr2 | 0 | 243199373 |
| chr3 | 0 | 198022430 |
| chr4 | 0 | 191154276 |
| ... | ... | ... |
| chr22 | 0 | 51304566 |
| chrM | 0 | 16571 |
| chrX | 0 | 155270560 |
| chrY | 0 | 59373566 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 25 rows and 3 columns from 25 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> pr.gf.tile_genome(chromsizes, int(1e6))
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 0 | 1000000 |
| chr1 | 1000000 | 2000000 |
| chr1 | 2000000 | 3000000 |
| chr1 | 3000000 | 4000000 |
| ... | ... | ... |
| chrY | 56000000 | 57000000 |
| chrY | 57000000 | 58000000 |
| chrY | 58000000 | 59000000 |
| chrY | 59000000 | 59373566 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3,114 rows and 3 columns from 25 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
|
tile_genome
|
python
|
pyranges/pyranges
|
pyranges/genomicfeatures.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/genomicfeatures.py
|
MIT
|
def get_sequence(gr, path=None, pyfaidx_fasta=None):
"""Get the sequence of the intervals from a fasta file
Parameters
----------
gr : PyRanges
Coordinates.
path : str
Path to fasta file. It will be indexed using pyfaidx if an index is not found
pyfaidx_fasta : pyfaidx.Fasta
Alternative method to provide fasta target, as a pyfaidx.Fasta object
Returns
-------
Series
Sequences, one per interval.
Note
----
This function requires the library pyfaidx, it can be installed with
``conda install -c bioconda pyfaidx`` or ``pip install pyfaidx``.
Sorting the PyRanges is likely to improve the speed.
Intervals on the negative strand will be reverse complemented.
Warning
-------
Note that the names in the fasta header and gr must be the same.
See also
--------
get_transcript_sequence : obtain mRNA sequences, by joining exons belonging to the same transcript
Examples
--------
>>> gr = pr.from_dict({"Chromosome": ["chr1", "chr1"],
... "Start": [5, 0], "End": [8, 5]})
>>> gr
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 5 | 8 |
| chr1 | 0 | 5 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> tmp_handle = open("temp.fasta", "w+")
>>> _ = tmp_handle.write(">chr1\\n")
>>> _ = tmp_handle.write("ATTACCAT\\n")
>>> tmp_handle.close()
>>> seq = pr.get_sequence(gr, "temp.fasta")
>>> seq
0 CAT
1 ATTAC
dtype: object
>>> gr.seq = seq
>>> gr
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | seq |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 5 | 8 | CAT |
| chr1 | 0 | 5 | ATTAC |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
"""
try:
import pyfaidx # type: ignore
except ImportError:
print(
"pyfaidx must be installed to get fasta sequences. Use `conda install -c bioconda pyfaidx` or `pip install pyfaidx` to install it."
)
sys.exit(1)
if pyfaidx_fasta is None:
if path is None:
raise Exception("ERROR get_sequence : you must provide a fasta path or pyfaidx_fasta object")
pyfaidx_fasta = pyfaidx.Fasta(path, read_ahead=int(1e5))
seqs = []
for k, df in gr:
if type(k) is tuple: # input is Stranded
_fasta = pyfaidx_fasta[k[0]]
if k[1] == "-":
for start, end in zip(df.Start, df.End):
seqs.append((-_fasta[start:end]).seq) # reverse complement
else:
for start, end in zip(df.Start, df.End):
seqs.append(_fasta[start:end].seq)
else:
_fasta = pyfaidx_fasta[k]
for start, end in zip(df.Start, df.End):
seqs.append(_fasta[start:end].seq)
return pd.concat([pd.Series(s) for s in seqs]).reset_index(drop=True)
|
Get the sequence of the intervals from a fasta file
Parameters
----------
gr : PyRanges
Coordinates.
path : str
Path to fasta file. It will be indexed using pyfaidx if an index is not found
pyfaidx_fasta : pyfaidx.Fasta
Alternative method to provide fasta target, as a pyfaidx.Fasta object
Returns
-------
Series
Sequences, one per interval.
Note
----
This function requires the library pyfaidx, it can be installed with
``conda install -c bioconda pyfaidx`` or ``pip install pyfaidx``.
Sorting the PyRanges is likely to improve the speed.
Intervals on the negative strand will be reverse complemented.
Warning
-------
Note that the names in the fasta header and gr must be the same.
See also
--------
get_transcript_sequence : obtain mRNA sequences, by joining exons belonging to the same transcript
Examples
--------
>>> gr = pr.from_dict({"Chromosome": ["chr1", "chr1"],
... "Start": [5, 0], "End": [8, 5]})
>>> gr
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 5 | 8 |
| chr1 | 0 | 5 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> tmp_handle = open("temp.fasta", "w+")
>>> _ = tmp_handle.write(">chr1\n")
>>> _ = tmp_handle.write("ATTACCAT\n")
>>> tmp_handle.close()
>>> seq = pr.get_sequence(gr, "temp.fasta")
>>> seq
0 CAT
1 ATTAC
dtype: object
>>> gr.seq = seq
>>> gr
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | seq |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 5 | 8 | CAT |
| chr1 | 0 | 5 | ATTAC |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
|
get_sequence
|
python
|
pyranges/pyranges
|
pyranges/get_fasta.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/get_fasta.py
|
MIT
|
def get_transcript_sequence(gr, group_by, path=None, pyfaidx_fasta=None):
"""Get the sequence of mRNAs, e.g. joining intervals corresponding to exons of the same transcript
Parameters
----------
gr : PyRanges
Coordinates.
group_by : str or list of str
intervals are grouped by this/these ID column(s): these are exons belonging to same transcript
path : str
Path to fasta file. It will be indexed using pyfaidx if an index is not found
pyfaidx_fasta : pyfaidx.Fasta
Alternative method to provide fasta target, as a pyfaidx.Fasta object
Returns
-------
DataFrame
Pandas DataFrame with a column for Sequence, plus ID column(s) provided with "group_by"
Note
----
This function requires the library pyfaidx, it can be installed with
``conda install -c bioconda pyfaidx`` or ``pip install pyfaidx``.
Sorting the PyRanges is likely to improve the speed.
Intervals on the negative strand will be reverse complemented.
Warning
-------
Note that the names in the fasta header and gr must be the same.
See also
--------
get_sequence : obtain sequence of single intervals
Examples
--------
>>> gr = pr.from_dict({"Chromosome": ['chr1', 'chr1', 'chr1'],
... "Start": [0, 9, 18], "End": [4, 13, 21],
... "Strand":['+', '-', '-'],
... "transcript": ['t1', 't2', 't2']})
>>> gr
+--------------+-----------+-----------+--------------+--------------+
| Chromosome | Start | End | Strand | transcript |
| (category) | (int64) | (int64) | (category) | (object) |
|--------------+-----------+-----------+--------------+--------------|
| chr1 | 0 | 4 | + | t1 |
| chr1 | 9 | 13 | - | t2 |
| chr1 | 18 | 21 | - | t2 |
+--------------+-----------+-----------+--------------+--------------+
Stranded PyRanges object has 3 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> tmp_handle = open("temp.fasta", "w+")
>>> _ = tmp_handle.write(">chr1\\n")
>>> _ = tmp_handle.write("AAACCCTTTGGGAAACCCTTTGGG\\n")
>>> tmp_handle.close()
>>> seq = pr.get_transcript_sequence(gr, path="temp.fasta", group_by='transcript')
>>> seq
transcript Sequence
0 t1 AAAC
1 t2 AAATCCC
To write to a file in fasta format:
# with open('outfile.fasta', 'w') as fw:
# nchars=60
# for row in seq.itertuples():
# s = '\\n'.join([ row.Sequence[i:i+nchars] for i in range(0, len(row.Sequence), nchars)])
# fw.write(f'>{row.transcript}\\n{s}\\n')
"""
if gr.stranded:
gr = gr.sort("5")
else:
gr = gr.sort()
z = gr.df
z["Sequence"] = get_sequence(gr, path=path, pyfaidx_fasta=pyfaidx_fasta)
return z.groupby(group_by, as_index=False, observed=False).agg({"Sequence": "".join})
|
Get the sequence of mRNAs, e.g. joining intervals corresponding to exons of the same transcript
Parameters
----------
gr : PyRanges
Coordinates.
group_by : str or list of str
intervals are grouped by this/these ID column(s): these are exons belonging to same transcript
path : str
Path to fasta file. It will be indexed using pyfaidx if an index is not found
pyfaidx_fasta : pyfaidx.Fasta
Alternative method to provide fasta target, as a pyfaidx.Fasta object
Returns
-------
DataFrame
Pandas DataFrame with a column for Sequence, plus ID column(s) provided with "group_by"
Note
----
This function requires the library pyfaidx, it can be installed with
``conda install -c bioconda pyfaidx`` or ``pip install pyfaidx``.
Sorting the PyRanges is likely to improve the speed.
Intervals on the negative strand will be reverse complemented.
Warning
-------
Note that the names in the fasta header and gr must be the same.
See also
--------
get_sequence : obtain sequence of single intervals
Examples
--------
>>> gr = pr.from_dict({"Chromosome": ['chr1', 'chr1', 'chr1'],
... "Start": [0, 9, 18], "End": [4, 13, 21],
... "Strand":['+', '-', '-'],
... "transcript": ['t1', 't2', 't2']})
>>> gr
+--------------+-----------+-----------+--------------+--------------+
| Chromosome | Start | End | Strand | transcript |
| (category) | (int64) | (int64) | (category) | (object) |
|--------------+-----------+-----------+--------------+--------------|
| chr1 | 0 | 4 | + | t1 |
| chr1 | 9 | 13 | - | t2 |
| chr1 | 18 | 21 | - | t2 |
+--------------+-----------+-----------+--------------+--------------+
Stranded PyRanges object has 3 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> tmp_handle = open("temp.fasta", "w+")
>>> _ = tmp_handle.write(">chr1\n")
>>> _ = tmp_handle.write("AAACCCTTTGGGAAACCCTTTGGG\n")
>>> tmp_handle.close()
>>> seq = pr.get_transcript_sequence(gr, path="temp.fasta", group_by='transcript')
>>> seq
transcript Sequence
0 t1 AAAC
1 t2 AAATCCC
To write to a file in fasta format:
# with open('outfile.fasta', 'w') as fw:
# nchars=60
# for row in seq.itertuples():
# s = '\n'.join([ row.Sequence[i:i+nchars] for i in range(0, len(row.Sequence), nchars)])
# fw.write(f'>{row.transcript}\n{s}\n')
|
get_transcript_sequence
|
python
|
pyranges/pyranges
|
pyranges/get_fasta.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/get_fasta.py
|
MIT
|
def count_overlaps(grs, features=None, strandedness=None, how=None, nb_cpu=1):
"""Count overlaps in multiple pyranges.
Parameters
----------
grs : dict of PyRanges
The PyRanges to use as queries.
features : PyRanges, default None
The PyRanges to use as subject in the query. If None, the PyRanges themselves are used as a query.
strandedness : {None, "same", "opposite", False}, default None, i.e. auto
Whether to compare PyRanges on the same strand, the opposite or ignore strand
information. The default, None, means use "same" if both PyRanges are stranded,
otherwise ignore the strand information.
how : {None, "all", "containment"}, default None, i.e. all
What intervals to report. By default reports all overlapping intervals. "containment"
reports intervals where the overlapping is contained within it.
nb_cpu : int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Examples
--------
>>> a = '''Chromosome Start End
... chr1 6 12
... chr1 10 20
... chr1 22 27
... chr1 24 30'''
>>> b = '''Chromosome Start End
... chr1 12 32
... chr1 14 30'''
>>> c = '''Chromosome Start End
... chr1 8 15
... chr1 10 14
... chr1 32 34'''
>>> grs = {n: pr.from_string(s) for n, s in zip(["a", "b", "c"], [a, b, c])}
>>> for k, v in grs.items():
... print("Name: " + k)
... print(v)
Name: a
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 6 | 12 |
| chr1 | 10 | 20 |
| chr1 | 22 | 27 |
| chr1 | 24 | 30 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
Name: b
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 12 | 32 |
| chr1 | 14 | 30 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
Name: c
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 8 | 15 |
| chr1 | 10 | 14 |
| chr1 | 32 | 34 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> pr.count_overlaps(grs)
+--------------+-----------+-----------+-----------+-----------+-----------+
| Chromosome | Start | End | a | b | c |
| (object) | (int64) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------+-----------|
| chr1 | 6 | 8 | 1 | 0 | 0 |
| chr1 | 8 | 10 | 1 | 0 | 1 |
| chr1 | 10 | 12 | 2 | 0 | 2 |
| chr1 | 12 | 14 | 1 | 1 | 2 |
| ... | ... | ... | ... | ... | ... |
| chr1 | 24 | 27 | 2 | 2 | 0 |
| chr1 | 27 | 30 | 1 | 2 | 0 |
| chr1 | 30 | 32 | 0 | 1 | 0 |
| chr1 | 32 | 34 | 0 | 0 | 1 |
+--------------+-----------+-----------+-----------+-----------+-----------+
Unstranded PyRanges object has 12 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr = pr.PyRanges(chromosomes=["chr1"] * 4, starts=[0, 10, 20, 30], ends=[10, 20, 30, 40])
>>> gr
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 0 | 10 |
| chr1 | 10 | 20 |
| chr1 | 20 | 30 |
| chr1 | 30 | 40 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> pr.count_overlaps(grs, gr)
+--------------+-----------+-----------+-----------+-----------+-----------+
| Chromosome | Start | End | a | b | c |
| (category) | (int64) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------+-----------|
| chr1 | 0 | 10 | 1 | 0 | 1 |
| chr1 | 10 | 20 | 2 | 2 | 2 |
| chr1 | 20 | 30 | 2 | 2 | 0 |
| chr1 | 30 | 40 | 0 | 1 | 1 |
+--------------+-----------+-----------+-----------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
"""
kwargs = {
"as_pyranges": False,
"nb_cpu": nb_cpu,
"strandedness": strandedness,
"how": how,
"nb_cpu": nb_cpu,
}
names = list(grs.keys())
if features is None:
features = pr.concat(grs.values()).split(between=True)
else:
features = features.copy()
from pyranges.methods.intersection import _count_overlaps
for name, gr in grs.items():
gr = gr.drop()
kwargs["name"] = name
features.apply_pair(gr, _count_overlaps, **kwargs) # count overlaps modifies the ranges in-place
def to_int(df):
df[names] = df[names].astype(np.int64)
return df
features = features.apply(to_int)
return features
|
Count overlaps in multiple pyranges.
Parameters
----------
grs : dict of PyRanges
The PyRanges to use as queries.
features : PyRanges, default None
The PyRanges to use as subject in the query. If None, the PyRanges themselves are used as a query.
strandedness : {None, "same", "opposite", False}, default None, i.e. auto
Whether to compare PyRanges on the same strand, the opposite or ignore strand
information. The default, None, means use "same" if both PyRanges are stranded,
otherwise ignore the strand information.
how : {None, "all", "containment"}, default None, i.e. all
What intervals to report. By default reports all overlapping intervals. "containment"
reports intervals where the overlapping is contained within it.
nb_cpu : int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Examples
--------
>>> a = '''Chromosome Start End
... chr1 6 12
... chr1 10 20
... chr1 22 27
... chr1 24 30'''
>>> b = '''Chromosome Start End
... chr1 12 32
... chr1 14 30'''
>>> c = '''Chromosome Start End
... chr1 8 15
... chr1 10 14
... chr1 32 34'''
>>> grs = {n: pr.from_string(s) for n, s in zip(["a", "b", "c"], [a, b, c])}
>>> for k, v in grs.items():
... print("Name: " + k)
... print(v)
Name: a
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 6 | 12 |
| chr1 | 10 | 20 |
| chr1 | 22 | 27 |
| chr1 | 24 | 30 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
Name: b
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 12 | 32 |
| chr1 | 14 | 30 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
Name: c
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 8 | 15 |
| chr1 | 10 | 14 |
| chr1 | 32 | 34 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> pr.count_overlaps(grs)
+--------------+-----------+-----------+-----------+-----------+-----------+
| Chromosome | Start | End | a | b | c |
| (object) | (int64) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------+-----------|
| chr1 | 6 | 8 | 1 | 0 | 0 |
| chr1 | 8 | 10 | 1 | 0 | 1 |
| chr1 | 10 | 12 | 2 | 0 | 2 |
| chr1 | 12 | 14 | 1 | 1 | 2 |
| ... | ... | ... | ... | ... | ... |
| chr1 | 24 | 27 | 2 | 2 | 0 |
| chr1 | 27 | 30 | 1 | 2 | 0 |
| chr1 | 30 | 32 | 0 | 1 | 0 |
| chr1 | 32 | 34 | 0 | 0 | 1 |
+--------------+-----------+-----------+-----------+-----------+-----------+
Unstranded PyRanges object has 12 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr = pr.PyRanges(chromosomes=["chr1"] * 4, starts=[0, 10, 20, 30], ends=[10, 20, 30, 40])
>>> gr
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 0 | 10 |
| chr1 | 10 | 20 |
| chr1 | 20 | 30 |
| chr1 | 30 | 40 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> pr.count_overlaps(grs, gr)
+--------------+-----------+-----------+-----------+-----------+-----------+
| Chromosome | Start | End | a | b | c |
| (category) | (int64) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------+-----------|
| chr1 | 0 | 10 | 1 | 0 | 1 |
| chr1 | 10 | 20 | 2 | 2 | 2 |
| chr1 | 20 | 30 | 2 | 2 | 0 |
| chr1 | 30 | 40 | 0 | 1 | 1 |
+--------------+-----------+-----------+-----------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
|
count_overlaps
|
python
|
pyranges/pyranges
|
pyranges/multioverlap.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/multioverlap.py
|
MIT
|
def fill_kwargs(kwargs):
"""Give the kwargs dict default options."""
defaults = {
"strandedness": None,
"overlap": True,
"how": None,
"invert": None,
"new_pos": None,
"suffixes": ["_a", "_b"],
"suffix": "_b",
"sparse": {"self": False, "other": False},
}
defaults.update(kwargs)
return defaults
|
Give the kwargs dict default options.
|
fill_kwargs
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def __array_ufunc__(self, *args, **kwargs):
"""Apply unary numpy-function.
Apply function to all columns which are not index, i.e. Chromosome,
Start, End nor Strand.
Notes
-----
Function must produce a vector of equal length.
Examples
--------
>>> gr = pr.from_dict({"Chromosome": [1, 2, 3], "Start": [1, 2, 3],
... "End": [2, 3, 4], "Score": [9, 16, 25], "Score2": [121, 144, 169],
... "Name": ["n1", "n2", "n3"]})
>>> gr
+--------------+-----------+-----------+-----------+-----------+------------+
| Chromosome | Start | End | Score | Score2 | Name |
| (category) | (int64) | (int64) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+-----------+-----------+------------|
| 1 | 1 | 2 | 9 | 121 | n1 |
| 2 | 2 | 3 | 16 | 144 | n2 |
| 3 | 3 | 4 | 25 | 169 | n3 |
+--------------+-----------+-----------+-----------+-----------+------------+
Unstranded PyRanges object has 3 rows and 6 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> np.sqrt(gr)
+--------------+-----------+-----------+-------------+-------------+------------+
| Chromosome | Start | End | Score | Score2 | Name |
| (category) | (int64) | (int64) | (float64) | (float64) | (object) |
|--------------+-----------+-----------+-------------+-------------+------------|
| 1 | 1 | 2 | 3 | 11 | n1 |
| 2 | 2 | 3 | 4 | 12 | n2 |
| 3 | 3 | 4 | 5 | 13 | n3 |
+--------------+-----------+-----------+-------------+-------------+------------+
Unstranded PyRanges object has 3 rows and 6 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
"""
func, call, gr = args
columns = list(gr.columns)
non_index = [c for c in columns if c not in ["Chromosome", "Start", "End", "Strand"]]
for chromosome, df in gr:
subset = df.head(1)[non_index].select_dtypes(include=np.number).columns
_v = getattr(func, call)(df[subset], **kwargs)
# print(_v)
# print(df[_c])
df[subset] = _v
return gr
# self.apply()
|
Apply unary numpy-function.
Apply function to all columns which are not index, i.e. Chromosome,
Start, End nor Strand.
Notes
-----
Function must produce a vector of equal length.
Examples
--------
>>> gr = pr.from_dict({"Chromosome": [1, 2, 3], "Start": [1, 2, 3],
... "End": [2, 3, 4], "Score": [9, 16, 25], "Score2": [121, 144, 169],
... "Name": ["n1", "n2", "n3"]})
>>> gr
+--------------+-----------+-----------+-----------+-----------+------------+
| Chromosome | Start | End | Score | Score2 | Name |
| (category) | (int64) | (int64) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+-----------+-----------+------------|
| 1 | 1 | 2 | 9 | 121 | n1 |
| 2 | 2 | 3 | 16 | 144 | n2 |
| 3 | 3 | 4 | 25 | 169 | n3 |
+--------------+-----------+-----------+-----------+-----------+------------+
Unstranded PyRanges object has 3 rows and 6 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> np.sqrt(gr)
+--------------+-----------+-----------+-------------+-------------+------------+
| Chromosome | Start | End | Score | Score2 | Name |
| (category) | (int64) | (int64) | (float64) | (float64) | (object) |
|--------------+-----------+-----------+-------------+-------------+------------|
| 1 | 1 | 2 | 3 | 11 | n1 |
| 2 | 2 | 3 | 4 | 12 | n2 |
| 3 | 3 | 4 | 5 | 13 | n3 |
+--------------+-----------+-----------+-------------+-------------+------------+
Unstranded PyRanges object has 3 rows and 6 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
|
__array_ufunc__
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def __getattr__(self, name):
"""Return column.
Parameters
----------
name : str
Column to return
Returns
-------
pandas.Series
Example
-------
>>> gr = pr.from_dict({"Chromosome": [1, 1, 1], "Start": [0, 100, 250], "End": [10, 125, 251]})
>>> gr.Start
0 0
1 100
2 250
Name: Start, dtype: int64
"""
from pyranges.methods.attr import _getattr
return _getattr(self, name)
|
Return column.
Parameters
----------
name : str
Column to return
Returns
-------
pandas.Series
Example
-------
>>> gr = pr.from_dict({"Chromosome": [1, 1, 1], "Start": [0, 100, 250], "End": [10, 125, 251]})
>>> gr.Start
0 0
1 100
2 250
Name: Start, dtype: int64
|
__getattr__
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def __setattr__(self, column_name, column):
"""Insert or update column.
Parameters
----------
column_name : str
Name of column to update or insert.
column : list, np.array or pd.Series
Data to insert.
Example
-------
>>> gr = pr.from_dict({"Chromosome": [1, 1, 1], "Start": [0, 100, 250], "End": [10, 125, 251]})
>>> gr.Start = np.array([1, 1, 2], dtype=np.int64)
>>> gr
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| 1 | 1 | 10 |
| 1 | 1 | 125 |
| 1 | 2 | 251 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
"""
from pyranges.methods.attr import _setattr
if column_name == "columns":
dfs = {}
for k, df in self:
df.columns = column
dfs[k] = df
self.__dict__["dfs"] = dfs
else:
_setattr(self, column_name, column)
if column_name in ["Start", "End"]:
if self.dtypes["Start"] != self.dtypes["End"]:
print(
"Warning! Start and End columns now have different dtypes: {} and {}".format(
self.dtypes["Start"], self.dtypes["End"]
)
)
|
Insert or update column.
Parameters
----------
column_name : str
Name of column to update or insert.
column : list, np.array or pd.Series
Data to insert.
Example
-------
>>> gr = pr.from_dict({"Chromosome": [1, 1, 1], "Start": [0, 100, 250], "End": [10, 125, 251]})
>>> gr.Start = np.array([1, 1, 2], dtype=np.int64)
>>> gr
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| 1 | 1 | 10 |
| 1 | 1 | 125 |
| 1 | 2 | 251 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
|
__setattr__
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def __getitem__(self, val):
"""Fetch columns or subset on position.
If a list is provided, the column(s) in the list is returned. This subsets on columns.
If a numpy array is provided, it must be of type bool and the same length as the PyRanges.
Otherwise, a subset of the rows is returned with the location info provided.
Parameters
----------
val : bool array/Series, tuple, list, str or slice
Data to fetch.
Examples
--------
>>> gr = pr.data.ensembl_gtf()
>>> list(gr.columns)
['Chromosome', 'Source', 'Feature', 'Start', 'End', 'Score', 'Strand', 'Frame', 'gene_biotype', 'gene_id', 'gene_name', 'gene_source', 'gene_version', 'tag', 'transcript_biotype', 'transcript_id', 'transcript_name', 'transcript_source', 'transcript_support_level', 'transcript_version', 'exon_id', 'exon_number', 'exon_version', '(assigned', 'previous', 'protein_id', 'protein_version', 'ccds_id']
>>> gr = gr[["Source", "Feature", "gene_id"]]
>>> gr
+--------------+------------+--------------+-----------+-----------+--------------+-----------------+
| Chromosome | Source | Feature | Start | End | Strand | gene_id |
| (category) | (object) | (category) | (int64) | (int64) | (category) | (object) |
|--------------+------------+--------------+-----------+-----------+--------------+-----------------|
| 1 | havana | gene | 11868 | 14409 | + | ENSG00000223972 |
| 1 | havana | transcript | 11868 | 14409 | + | ENSG00000223972 |
| 1 | havana | exon | 11868 | 12227 | + | ENSG00000223972 |
| 1 | havana | exon | 12612 | 12721 | + | ENSG00000223972 |
| ... | ... | ... | ... | ... | ... | ... |
| 1 | havana | gene | 1173055 | 1179555 | - | ENSG00000205231 |
| 1 | havana | transcript | 1173055 | 1179555 | - | ENSG00000205231 |
| 1 | havana | exon | 1179364 | 1179555 | - | ENSG00000205231 |
| 1 | havana | exon | 1173055 | 1176396 | - | ENSG00000205231 |
+--------------+------------+--------------+-----------+-----------+--------------+-----------------+
Stranded PyRanges object has 2,446 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
Create boolean Series and use it to subset:
>>> s = (gr.Feature == "gene") | (gr.gene_id == "ENSG00000223972")
>>> gr[s]
+--------------+----------------+--------------+-----------+-----------+--------------+-----------------+
| Chromosome | Source | Feature | Start | End | Strand | gene_id |
| (category) | (object) | (category) | (int64) | (int64) | (category) | (object) |
|--------------+----------------+--------------+-----------+-----------+--------------+-----------------|
| 1 | havana | gene | 11868 | 14409 | + | ENSG00000223972 |
| 1 | havana | transcript | 11868 | 14409 | + | ENSG00000223972 |
| 1 | havana | exon | 11868 | 12227 | + | ENSG00000223972 |
| 1 | havana | exon | 12612 | 12721 | + | ENSG00000223972 |
| ... | ... | ... | ... | ... | ... | ... |
| 1 | havana | gene | 1062207 | 1063288 | - | ENSG00000273443 |
| 1 | ensembl_havana | gene | 1070966 | 1074306 | - | ENSG00000237330 |
| 1 | ensembl_havana | gene | 1081817 | 1116361 | - | ENSG00000131591 |
| 1 | havana | gene | 1173055 | 1179555 | - | ENSG00000205231 |
+--------------+----------------+--------------+-----------+-----------+--------------+-----------------+
Stranded PyRanges object has 95 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> cs = pr.data.chipseq()
>>> cs[10000:100000]
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr2 | 33241 | 33266 | U0 | 0 | + |
| chr2 | 13611 | 13636 | U0 | 0 | - |
| chr2 | 32620 | 32645 | U0 | 0 | - |
| chr3 | 87179 | 87204 | U0 | 0 | + |
| chr4 | 45413 | 45438 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 5 rows and 6 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> cs["chr1", "-"]
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 100079649 | 100079674 | U0 | 0 | - |
| chr1 | 223587418 | 223587443 | U0 | 0 | - |
| chr1 | 202450161 | 202450186 | U0 | 0 | - |
| chr1 | 156338310 | 156338335 | U0 | 0 | - |
| ... | ... | ... | ... | ... | ... |
| chr1 | 203557775 | 203557800 | U0 | 0 | - |
| chr1 | 28114107 | 28114132 | U0 | 0 | - |
| chr1 | 21622765 | 21622790 | U0 | 0 | - |
| chr1 | 80668132 | 80668157 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 437 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> cs["chr5", "-", 90000:]
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr5 | 399682 | 399707 | U0 | 0 | - |
| chr5 | 1847502 | 1847527 | U0 | 0 | - |
| chr5 | 5247533 | 5247558 | U0 | 0 | - |
| chr5 | 5300394 | 5300419 | U0 | 0 | - |
| ... | ... | ... | ... | ... | ... |
| chr5 | 178786234 | 178786259 | U0 | 0 | - |
| chr5 | 179268931 | 179268956 | U0 | 0 | - |
| chr5 | 179289594 | 179289619 | U0 | 0 | - |
| chr5 | 180513795 | 180513820 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 285 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> cs["chrM"]
Empty PyRanges
"""
from pyranges.methods.getitem import _getitem
return _getitem(self, val)
|
Fetch columns or subset on position.
If a list is provided, the column(s) in the list is returned. This subsets on columns.
If a numpy array is provided, it must be of type bool and the same length as the PyRanges.
Otherwise, a subset of the rows is returned with the location info provided.
Parameters
----------
val : bool array/Series, tuple, list, str or slice
Data to fetch.
Examples
--------
>>> gr = pr.data.ensembl_gtf()
>>> list(gr.columns)
['Chromosome', 'Source', 'Feature', 'Start', 'End', 'Score', 'Strand', 'Frame', 'gene_biotype', 'gene_id', 'gene_name', 'gene_source', 'gene_version', 'tag', 'transcript_biotype', 'transcript_id', 'transcript_name', 'transcript_source', 'transcript_support_level', 'transcript_version', 'exon_id', 'exon_number', 'exon_version', '(assigned', 'previous', 'protein_id', 'protein_version', 'ccds_id']
>>> gr = gr[["Source", "Feature", "gene_id"]]
>>> gr
+--------------+------------+--------------+-----------+-----------+--------------+-----------------+
| Chromosome | Source | Feature | Start | End | Strand | gene_id |
| (category) | (object) | (category) | (int64) | (int64) | (category) | (object) |
|--------------+------------+--------------+-----------+-----------+--------------+-----------------|
| 1 | havana | gene | 11868 | 14409 | + | ENSG00000223972 |
| 1 | havana | transcript | 11868 | 14409 | + | ENSG00000223972 |
| 1 | havana | exon | 11868 | 12227 | + | ENSG00000223972 |
| 1 | havana | exon | 12612 | 12721 | + | ENSG00000223972 |
| ... | ... | ... | ... | ... | ... | ... |
| 1 | havana | gene | 1173055 | 1179555 | - | ENSG00000205231 |
| 1 | havana | transcript | 1173055 | 1179555 | - | ENSG00000205231 |
| 1 | havana | exon | 1179364 | 1179555 | - | ENSG00000205231 |
| 1 | havana | exon | 1173055 | 1176396 | - | ENSG00000205231 |
+--------------+------------+--------------+-----------+-----------+--------------+-----------------+
Stranded PyRanges object has 2,446 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
Create boolean Series and use it to subset:
>>> s = (gr.Feature == "gene") | (gr.gene_id == "ENSG00000223972")
>>> gr[s]
+--------------+----------------+--------------+-----------+-----------+--------------+-----------------+
| Chromosome | Source | Feature | Start | End | Strand | gene_id |
| (category) | (object) | (category) | (int64) | (int64) | (category) | (object) |
|--------------+----------------+--------------+-----------+-----------+--------------+-----------------|
| 1 | havana | gene | 11868 | 14409 | + | ENSG00000223972 |
| 1 | havana | transcript | 11868 | 14409 | + | ENSG00000223972 |
| 1 | havana | exon | 11868 | 12227 | + | ENSG00000223972 |
| 1 | havana | exon | 12612 | 12721 | + | ENSG00000223972 |
| ... | ... | ... | ... | ... | ... | ... |
| 1 | havana | gene | 1062207 | 1063288 | - | ENSG00000273443 |
| 1 | ensembl_havana | gene | 1070966 | 1074306 | - | ENSG00000237330 |
| 1 | ensembl_havana | gene | 1081817 | 1116361 | - | ENSG00000131591 |
| 1 | havana | gene | 1173055 | 1179555 | - | ENSG00000205231 |
+--------------+----------------+--------------+-----------+-----------+--------------+-----------------+
Stranded PyRanges object has 95 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> cs = pr.data.chipseq()
>>> cs[10000:100000]
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr2 | 33241 | 33266 | U0 | 0 | + |
| chr2 | 13611 | 13636 | U0 | 0 | - |
| chr2 | 32620 | 32645 | U0 | 0 | - |
| chr3 | 87179 | 87204 | U0 | 0 | + |
| chr4 | 45413 | 45438 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 5 rows and 6 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> cs["chr1", "-"]
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 100079649 | 100079674 | U0 | 0 | - |
| chr1 | 223587418 | 223587443 | U0 | 0 | - |
| chr1 | 202450161 | 202450186 | U0 | 0 | - |
| chr1 | 156338310 | 156338335 | U0 | 0 | - |
| ... | ... | ... | ... | ... | ... |
| chr1 | 203557775 | 203557800 | U0 | 0 | - |
| chr1 | 28114107 | 28114132 | U0 | 0 | - |
| chr1 | 21622765 | 21622790 | U0 | 0 | - |
| chr1 | 80668132 | 80668157 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 437 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> cs["chr5", "-", 90000:]
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr5 | 399682 | 399707 | U0 | 0 | - |
| chr5 | 1847502 | 1847527 | U0 | 0 | - |
| chr5 | 5247533 | 5247558 | U0 | 0 | - |
| chr5 | 5300394 | 5300419 | U0 | 0 | - |
| ... | ... | ... | ... | ... | ... |
| chr5 | 178786234 | 178786259 | U0 | 0 | - |
| chr5 | 179268931 | 179268956 | U0 | 0 | - |
| chr5 | 179289594 | 179289619 | U0 | 0 | - |
| chr5 | 180513795 | 180513820 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 285 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> cs["chrM"]
Empty PyRanges
|
__getitem__
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def apply(self, f, strand=None, as_pyranges=True, nb_cpu=1, **kwargs):
"""Apply a function to the PyRanges.
Parameters
----------
f : function
Function to apply on each DataFrame in a PyRanges
strand : bool, default None, i.e. auto
Whether to do operations on chromosome/strand pairs or chromosomes. If None, will use
chromosome/strand pairs if the PyRanges is stranded.
as_pyranges : bool, default True
Whether to return as a PyRanges or dict. If `f` does not return a DataFrame valid for
PyRanges, `as_pyranges` must be False.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
**kwargs
Additional keyword arguments to pass as keyword arguments to `f`
Returns
-------
PyRanges or dict
Result of applying f to each DataFrame in the PyRanges
See also
--------
pyranges.PyRanges.apply_pair: apply a function to a pair of PyRanges
pyranges.PyRanges.apply_chunks: apply a row-based function to a PyRanges in parallel
Note
----
This is the function used internally to carry out almost all unary PyRanges methods.
Examples
--------
>>> gr = pr.from_dict({"Chromosome": [1, 1, 2, 2], "Strand": ["+", "+", "-", "+"],
... "Start": [1, 4, 2, 9], "End": [2, 27, 13, 10]})
>>> gr
+--------------+--------------+-----------+-----------+
| Chromosome | Strand | Start | End |
| (category) | (category) | (int64) | (int64) |
|--------------+--------------+-----------+-----------|
| 1 | + | 1 | 2 |
| 1 | + | 4 | 27 |
| 2 | + | 9 | 10 |
| 2 | - | 2 | 13 |
+--------------+--------------+-----------+-----------+
Stranded PyRanges object has 4 rows and 4 columns from 2 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.apply(lambda df: len(df), as_pyranges=False)
{('1', '+'): 2, ('2', '+'): 1, ('2', '-'): 1}
>>> gr.apply(lambda df: len(df), as_pyranges=False, strand=False)
{'1': 2, '2': 2}
>>> def add_to_ends(df, **kwargs):
... df.loc[:, "End"] = kwargs["slack"] + df.End
... return df
>>> gr.apply(add_to_ends, slack=500)
+--------------+--------------+-----------+-----------+
| Chromosome | Strand | Start | End |
| (category) | (category) | (int64) | (int64) |
|--------------+--------------+-----------+-----------|
| 1 | + | 1 | 502 |
| 1 | + | 4 | 527 |
| 2 | + | 9 | 510 |
| 2 | - | 2 | 513 |
+--------------+--------------+-----------+-----------+
Stranded PyRanges object has 4 rows and 4 columns from 2 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
if strand is None:
strand = self.stranded
kwargs.update({"strand": strand})
kwargs.update(kwargs.get("kwargs", {}))
kwargs = fill_kwargs(kwargs)
result = pyrange_apply_single(f, self, **kwargs)
if not as_pyranges:
return result
else:
return PyRanges(result)
|
Apply a function to the PyRanges.
Parameters
----------
f : function
Function to apply on each DataFrame in a PyRanges
strand : bool, default None, i.e. auto
Whether to do operations on chromosome/strand pairs or chromosomes. If None, will use
chromosome/strand pairs if the PyRanges is stranded.
as_pyranges : bool, default True
Whether to return as a PyRanges or dict. If `f` does not return a DataFrame valid for
PyRanges, `as_pyranges` must be False.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
**kwargs
Additional keyword arguments to pass as keyword arguments to `f`
Returns
-------
PyRanges or dict
Result of applying f to each DataFrame in the PyRanges
See also
--------
pyranges.PyRanges.apply_pair: apply a function to a pair of PyRanges
pyranges.PyRanges.apply_chunks: apply a row-based function to a PyRanges in parallel
Note
----
This is the function used internally to carry out almost all unary PyRanges methods.
Examples
--------
>>> gr = pr.from_dict({"Chromosome": [1, 1, 2, 2], "Strand": ["+", "+", "-", "+"],
... "Start": [1, 4, 2, 9], "End": [2, 27, 13, 10]})
>>> gr
+--------------+--------------+-----------+-----------+
| Chromosome | Strand | Start | End |
| (category) | (category) | (int64) | (int64) |
|--------------+--------------+-----------+-----------|
| 1 | + | 1 | 2 |
| 1 | + | 4 | 27 |
| 2 | + | 9 | 10 |
| 2 | - | 2 | 13 |
+--------------+--------------+-----------+-----------+
Stranded PyRanges object has 4 rows and 4 columns from 2 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.apply(lambda df: len(df), as_pyranges=False)
{('1', '+'): 2, ('2', '+'): 1, ('2', '-'): 1}
>>> gr.apply(lambda df: len(df), as_pyranges=False, strand=False)
{'1': 2, '2': 2}
>>> def add_to_ends(df, **kwargs):
... df.loc[:, "End"] = kwargs["slack"] + df.End
... return df
>>> gr.apply(add_to_ends, slack=500)
+--------------+--------------+-----------+-----------+
| Chromosome | Strand | Start | End |
| (category) | (category) | (int64) | (int64) |
|--------------+--------------+-----------+-----------|
| 1 | + | 1 | 502 |
| 1 | + | 4 | 527 |
| 2 | + | 9 | 510 |
| 2 | - | 2 | 513 |
+--------------+--------------+-----------+-----------+
Stranded PyRanges object has 4 rows and 4 columns from 2 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
apply
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def apply_chunks(self, f, as_pyranges=False, nb_cpu=1, **kwargs):
"""Apply a row-based function to arbitrary partitions of the PyRanges.
apply_chunks speeds up the application of functions where the result is not affected by
applying the function to ordered, non-overlapping splits of the data.
Parameters
----------
f : function
Row-based or associative function to apply on the partitions.
as_pyranges : bool, default False
Whether to return as a PyRanges or dict.
nb_cpu: int, default 1
How many cpus to use. The data is split into nb_cpu partitions.
**kwargs
Additional keyword arguments to pass as keyword arguments to `f`
Returns
-------
dict of lists
Result of applying f to each partition of the DataFrames in the PyRanges.
See also
--------
pyranges.PyRanges.apply_pair: apply a function to a pair of PyRanges
pyranges.PyRanges.apply_chunks: apply a row-based function to a PyRanges in parallel
Note
----
apply_chunks will only lead to speedups on large datasets or slow-running functions. Using
it with nb_cpu=1 is pointless; use apply instead.
Examples
--------
>>> gr = pr.from_dict({"Chromosome": [1, 1, 1], "Start": [2, 3, 5], "End": [9, 4, 6]})
>>> gr
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| 1 | 2 | 9 |
| 1 | 3 | 4 |
| 1 | 5 | 6 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.apply_chunks(
... lambda df, **kwargs: list(df.End + kwargs["add"]), nb_cpu=1, add=1000)
{'1': [[1009, 1004, 1006]]}
"""
kwargs.update(kwargs.get("kwargs", {}))
kwargs = fill_kwargs(kwargs)
result = pyrange_apply_chunks(f, self, as_pyranges, **kwargs)
return result
|
Apply a row-based function to arbitrary partitions of the PyRanges.
apply_chunks speeds up the application of functions where the result is not affected by
applying the function to ordered, non-overlapping splits of the data.
Parameters
----------
f : function
Row-based or associative function to apply on the partitions.
as_pyranges : bool, default False
Whether to return as a PyRanges or dict.
nb_cpu: int, default 1
How many cpus to use. The data is split into nb_cpu partitions.
**kwargs
Additional keyword arguments to pass as keyword arguments to `f`
Returns
-------
dict of lists
Result of applying f to each partition of the DataFrames in the PyRanges.
See also
--------
pyranges.PyRanges.apply_pair: apply a function to a pair of PyRanges
pyranges.PyRanges.apply_chunks: apply a row-based function to a PyRanges in parallel
Note
----
apply_chunks will only lead to speedups on large datasets or slow-running functions. Using
it with nb_cpu=1 is pointless; use apply instead.
Examples
--------
>>> gr = pr.from_dict({"Chromosome": [1, 1, 1], "Start": [2, 3, 5], "End": [9, 4, 6]})
>>> gr
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| 1 | 2 | 9 |
| 1 | 3 | 4 |
| 1 | 5 | 6 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.apply_chunks(
... lambda df, **kwargs: list(df.End + kwargs["add"]), nb_cpu=1, add=1000)
{'1': [[1009, 1004, 1006]]}
|
apply_chunks
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def apply_pair(self, other, f, strandedness=None, as_pyranges=True, **kwargs):
"""Apply a function to a pair of PyRanges.
The function is applied to each chromosome or chromosome/strand pair found in at least one
of the PyRanges.
Parameters
----------
f : function
Row-based or associative function to apply on the DataFrames.
strandedness : {None, "same", "opposite", False}, default None, i.e. auto
Whether to compare PyRanges on the same strand, the opposite or ignore strand
information. The default, None, means use "same" if both PyRanges are strande,
otherwise ignore the strand information.
as_pyranges : bool, default False
Whether to return as a PyRanges or dict. If `f` does not return a DataFrame valid for
PyRanges, `as_pyranges` must be False.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
**kwargs
Additional keyword arguments to pass as keyword arguments to `f`
Returns
-------
dict of lists
Result of applying f to each partition of the DataFrames in the PyRanges.
See also
--------
pyranges.PyRanges.apply_pair: apply a function to a pair of PyRanges
pyranges.PyRanges.apply_chunks: apply a row-based function to a PyRanges in parallel
pyranges.iter: iterate over two or more PyRanges
Note
----
This is the function used internally to carry out almost all comparison functions in
PyRanges.
Examples
--------
>>> gr = pr.data.chipseq()
>>> gr2 = pr.data.chipseq_background()
>>> gr.apply_pair(gr2, pr.methods.intersection._intersection) # same as gr.intersect(gr2)
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 226987603 | 226987617 | U0 | 0 | + |
| chr8 | 38747236 | 38747251 | U0 | 0 | - |
| chr15 | 26105515 | 26105518 | U0 | 0 | + |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 3 rows and 6 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f1 = pr.data.f1()
>>> f1
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 3 | 6 | interval1 | 0 | + |
| chr1 | 8 | 9 | interval3 | 0 | + |
| chr1 | 5 | 7 | interval2 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 3 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f2 = pr.data.f2()
>>> f2
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 1 | 2 | a | 0 | + |
| chr1 | 6 | 7 | b | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 2 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f1.apply_pair(f2, lambda df, df2: (len(df), len(df2)), as_pyranges=False)
{('chr1', '+'): (2, 2), ('chr1', '-'): (1, 2)}
"""
kwargs.update({"strandedness": strandedness})
kwargs.update(kwargs.get("kwargs", {}))
kwargs = fill_kwargs(kwargs)
result = pyrange_apply(f, self, other, **kwargs)
if not as_pyranges:
return result
else:
return PyRanges(result)
|
Apply a function to a pair of PyRanges.
The function is applied to each chromosome or chromosome/strand pair found in at least one
of the PyRanges.
Parameters
----------
f : function
Row-based or associative function to apply on the DataFrames.
strandedness : {None, "same", "opposite", False}, default None, i.e. auto
Whether to compare PyRanges on the same strand, the opposite or ignore strand
information. The default, None, means use "same" if both PyRanges are strande,
otherwise ignore the strand information.
as_pyranges : bool, default False
Whether to return as a PyRanges or dict. If `f` does not return a DataFrame valid for
PyRanges, `as_pyranges` must be False.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
**kwargs
Additional keyword arguments to pass as keyword arguments to `f`
Returns
-------
dict of lists
Result of applying f to each partition of the DataFrames in the PyRanges.
See also
--------
pyranges.PyRanges.apply_pair: apply a function to a pair of PyRanges
pyranges.PyRanges.apply_chunks: apply a row-based function to a PyRanges in parallel
pyranges.iter: iterate over two or more PyRanges
Note
----
This is the function used internally to carry out almost all comparison functions in
PyRanges.
Examples
--------
>>> gr = pr.data.chipseq()
>>> gr2 = pr.data.chipseq_background()
>>> gr.apply_pair(gr2, pr.methods.intersection._intersection) # same as gr.intersect(gr2)
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 226987603 | 226987617 | U0 | 0 | + |
| chr8 | 38747236 | 38747251 | U0 | 0 | - |
| chr15 | 26105515 | 26105518 | U0 | 0 | + |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 3 rows and 6 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f1 = pr.data.f1()
>>> f1
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 3 | 6 | interval1 | 0 | + |
| chr1 | 8 | 9 | interval3 | 0 | + |
| chr1 | 5 | 7 | interval2 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 3 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f2 = pr.data.f2()
>>> f2
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 1 | 2 | a | 0 | + |
| chr1 | 6 | 7 | b | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 2 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f1.apply_pair(f2, lambda df, df2: (len(df), len(df2)), as_pyranges=False)
{('chr1', '+'): (2, 2), ('chr1', '-'): (1, 2)}
|
apply_pair
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def as_df(self):
"""Return PyRanges as DataFrame.
Returns
-------
DataFrame
A DataFrame natural sorted on Chromosome and Strand. The ordering of rows within
chromosomes and strands is preserved.
See also
--------
PyRanges.df : Return PyRanges as DataFrame.
Examples
--------
>>> gr = pr.from_dict({"Chromosome": [1, 1, 2, 2], "Start": [1, 2, 3, 9],
... "End": [3, 3, 10, 12], "Gene": ["A", "B", "C", "D"]})
>>> gr
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | Gene |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| 1 | 1 | 3 | A |
| 1 | 2 | 3 | B |
| 2 | 3 | 10 | C |
| 2 | 9 | 12 | D |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 4 rows and 4 columns from 2 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.as_df()
Chromosome Start End Gene
0 1 1 3 A
1 1 2 3 B
2 2 3 10 C
3 2 9 12 D
"""
if len(self) == 0:
return pd.DataFrame()
elif len(self) == 1:
return self.values()[0]
else:
return pd.concat(self.values()).reset_index(drop=True)
|
Return PyRanges as DataFrame.
Returns
-------
DataFrame
A DataFrame natural sorted on Chromosome and Strand. The ordering of rows within
chromosomes and strands is preserved.
See also
--------
PyRanges.df : Return PyRanges as DataFrame.
Examples
--------
>>> gr = pr.from_dict({"Chromosome": [1, 1, 2, 2], "Start": [1, 2, 3, 9],
... "End": [3, 3, 10, 12], "Gene": ["A", "B", "C", "D"]})
>>> gr
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | Gene |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| 1 | 1 | 3 | A |
| 1 | 2 | 3 | B |
| 2 | 3 | 10 | C |
| 2 | 9 | 12 | D |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 4 rows and 4 columns from 2 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.as_df()
Chromosome Start End Gene
0 1 1 3 A
1 1 2 3 B
2 2 3 10 C
3 2 9 12 D
|
as_df
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def assign(self, col, f, strand=None, nb_cpu=1, **kwargs):
"""Add or replace a column.
Does not change the original PyRanges.
Parameters
----------
col : str
Name of column.
f : function
Function to create new column.
strand : bool, default None, i.e. auto
Whether to do operations on chromosome/strand pairs or chromosomes. If None, will use
chromosome/strand pairs if the PyRanges is stranded.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
**kwargs
Additional keyword arguments to pass as keyword arguments to `f`
Returns
-------
PyRanges
A copy of the PyRanges with the column inserted.
Examples
--------
>>> gr = pr.from_dict({"Chromosome": [1, 1], "Start": [1, 2], "End": [3, 5],
... "Name": ["a", "b"]})
>>> gr
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | Name |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| 1 | 1 | 3 | a |
| 1 | 2 | 5 | b |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.assign("Blabla", lambda df: df.Chromosome.astype(str) + "_yadayada")
+--------------+-----------+-----------+------------+------------+
| Chromosome | Start | End | Name | Blabla |
| (category) | (int64) | (int64) | (object) | (object) |
|--------------+-----------+-----------+------------+------------|
| 1 | 1 | 3 | a | 1_yadayada |
| 1 | 2 | 5 | b | 1_yadayada |
+--------------+-----------+-----------+------------+------------+
Unstranded PyRanges object has 2 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
Note that assigning to an existing name replaces the column:
>>> gr.assign("Name",
... lambda df, **kwargs: df.Start.astype(str) + kwargs["sep"] +
... df.Name.str.capitalize(), sep="_")
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | Name |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| 1 | 1 | 3 | 1_A |
| 1 | 2 | 5 | 2_B |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
"""
self = self.copy()
if strand is None:
strand = self.stranded
kwargs["strand"] = strand
kwargs = fill_kwargs(kwargs)
result = pyrange_apply_single(f, self, **kwargs)
first_result = next(iter(result.values()))
assert isinstance(first_result, pd.Series), "result of assign function must be Series, but is {}".format(
type(first_result)
)
# do a deepcopy of object
new_self = self.copy()
new_self.__setattr__(col, result)
return new_self
|
Add or replace a column.
Does not change the original PyRanges.
Parameters
----------
col : str
Name of column.
f : function
Function to create new column.
strand : bool, default None, i.e. auto
Whether to do operations on chromosome/strand pairs or chromosomes. If None, will use
chromosome/strand pairs if the PyRanges is stranded.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
**kwargs
Additional keyword arguments to pass as keyword arguments to `f`
Returns
-------
PyRanges
A copy of the PyRanges with the column inserted.
Examples
--------
>>> gr = pr.from_dict({"Chromosome": [1, 1], "Start": [1, 2], "End": [3, 5],
... "Name": ["a", "b"]})
>>> gr
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | Name |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| 1 | 1 | 3 | a |
| 1 | 2 | 5 | b |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.assign("Blabla", lambda df: df.Chromosome.astype(str) + "_yadayada")
+--------------+-----------+-----------+------------+------------+
| Chromosome | Start | End | Name | Blabla |
| (category) | (int64) | (int64) | (object) | (object) |
|--------------+-----------+-----------+------------+------------|
| 1 | 1 | 3 | a | 1_yadayada |
| 1 | 2 | 5 | b | 1_yadayada |
+--------------+-----------+-----------+------------+------------+
Unstranded PyRanges object has 2 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
Note that assigning to an existing name replaces the column:
>>> gr.assign("Name",
... lambda df, **kwargs: df.Start.astype(str) + kwargs["sep"] +
... df.Name.str.capitalize(), sep="_")
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | Name |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| 1 | 1 | 3 | 1_A |
| 1 | 2 | 5 | 2_B |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
|
assign
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def boundaries(self, group_by, agg=None):
"""Return the boundaries of groups of intervals (e.g. transcripts)
Parameters
----------
group_by : str or list of str
Name(s) of column(s) to group intervals
agg : dict or None
Defines how to aggregate metadata columns. Provided as
dictionary of column names -> functions, function names or list of such,
as accepted by the Pandas.DataFrame.agg method.
Returns
-------
PyRanges
One interval per group, with the min(Start) and max(End) of the group
Examples
--------
>>> d = {"Chromosome": [1, 1, 1], "Start": [1, 60, 110], "End": [40, 68, 130], "transcript_id": ["tr1", "tr1", "tr2"], "meta": ["a", "b", "c"]}
>>> gr = pr.from_dict(d)
>>> gr.length=gr.lengths()
>>> gr
+--------------+-----------+-----------+-----------------+------------+-----------+
| Chromosome | Start | End | transcript_id | meta | length |
| (category) | (int64) | (int64) | (object) | (object) | (int64) |
|--------------+-----------+-----------+-----------------+------------+-----------|
| 1 | 1 | 40 | tr1 | a | 39 |
| 1 | 60 | 68 | tr1 | b | 8 |
| 1 | 110 | 130 | tr2 | c | 20 |
+--------------+-----------+-----------+-----------------+------------+-----------+
Unstranded PyRanges object has 3 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.boundaries("transcript_id")
+--------------+-----------+-----------+-----------------+
| Chromosome | Start | End | transcript_id |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+-----------------|
| 1 | 1 | 68 | tr1 |
| 1 | 110 | 130 | tr2 |
+--------------+-----------+-----------+-----------------+
Unstranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.boundaries("transcript_id", agg={"length":"sum", "meta": ",".join})
+--------------+-----------+-----------+-----------------+------------+-----------+
| Chromosome | Start | End | transcript_id | meta | length |
| (category) | (int64) | (int64) | (object) | (object) | (int64) |
|--------------+-----------+-----------+-----------------+------------+-----------|
| 1 | 1 | 68 | tr1 | a,b | 47 |
| 1 | 110 | 130 | tr2 | c | 20 |
+--------------+-----------+-----------+-----------------+------------+-----------+
Unstranded PyRanges object has 2 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
"""
from pyranges.methods.boundaries import _bounds
kwargs = {"group_by": group_by, "agg": agg, "strand": self.stranded}
kwargs = fill_kwargs(kwargs)
result = pyrange_apply_single(_bounds, self, **kwargs)
return pr.PyRanges(result)
|
Return the boundaries of groups of intervals (e.g. transcripts)
Parameters
----------
group_by : str or list of str
Name(s) of column(s) to group intervals
agg : dict or None
Defines how to aggregate metadata columns. Provided as
dictionary of column names -> functions, function names or list of such,
as accepted by the Pandas.DataFrame.agg method.
Returns
-------
PyRanges
One interval per group, with the min(Start) and max(End) of the group
Examples
--------
>>> d = {"Chromosome": [1, 1, 1], "Start": [1, 60, 110], "End": [40, 68, 130], "transcript_id": ["tr1", "tr1", "tr2"], "meta": ["a", "b", "c"]}
>>> gr = pr.from_dict(d)
>>> gr.length=gr.lengths()
>>> gr
+--------------+-----------+-----------+-----------------+------------+-----------+
| Chromosome | Start | End | transcript_id | meta | length |
| (category) | (int64) | (int64) | (object) | (object) | (int64) |
|--------------+-----------+-----------+-----------------+------------+-----------|
| 1 | 1 | 40 | tr1 | a | 39 |
| 1 | 60 | 68 | tr1 | b | 8 |
| 1 | 110 | 130 | tr2 | c | 20 |
+--------------+-----------+-----------+-----------------+------------+-----------+
Unstranded PyRanges object has 3 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.boundaries("transcript_id")
+--------------+-----------+-----------+-----------------+
| Chromosome | Start | End | transcript_id |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+-----------------|
| 1 | 1 | 68 | tr1 |
| 1 | 110 | 130 | tr2 |
+--------------+-----------+-----------+-----------------+
Unstranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.boundaries("transcript_id", agg={"length":"sum", "meta": ",".join})
+--------------+-----------+-----------+-----------------+------------+-----------+
| Chromosome | Start | End | transcript_id | meta | length |
| (category) | (int64) | (int64) | (object) | (object) | (int64) |
|--------------+-----------+-----------+-----------------+------------+-----------|
| 1 | 1 | 68 | tr1 | a,b | 47 |
| 1 | 110 | 130 | tr2 | c | 20 |
+--------------+-----------+-----------+-----------------+------------+-----------+
Unstranded PyRanges object has 2 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
|
boundaries
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def calculate_frame(self, by):
"""Calculate the frame of each genomic interval, assuming all are coding sequences (CDS), and add it as column inplace.
After this, the input Pyranges will contain an added "Frame" column, which determines the base of the CDS that is the first base of a codon.
Resulting values are in range between 0 and 2 included. 0 indicates that the first base of the CDS is the first base of a codon,
1 indicates the second base and 2 indicates the third base of the CDS.
While the 5'-most interval of each transcript has always 0 frame, the following ones may have any of these values.
Parameters
----------
by : str or list of str
Column(s) to group by the intervals: coding exons belonging to the same transcript have the same values in this/these column(s).
Returns
-------
None
The "Frame" column is added inplace.
Examples
--------
>>> p= pr.from_dict({"Chromosome": [1,1,1,2,2],
... "Strand": ["+","+","+","-","-"],
... "Start": [1,31,52,101,201],
... "End": [10,45,90,130,218],
... "transcript_id": ["t1","t1","t1","t2","t2"] })
>>> p
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 1 | 10 | t1 |
| 1 | + | 31 | 45 | t1 |
| 1 | + | 52 | 90 | t1 |
| 2 | - | 101 | 130 | t2 |
| 2 | - | 201 | 218 | t2 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 5 rows and 5 columns from 2 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> p.calculate_frame(by=['transcript_id'])
>>> p
+--------------+--------------+-----------+-----------+-----------------+-----------+
| Chromosome | Strand | Start | End | transcript_id | Frame |
| (category) | (category) | (int64) | (int64) | (object) | (int64) |
|--------------+--------------+-----------+-----------+-----------------+-----------|
| 1 | + | 1 | 10 | t1 | 0 |
| 1 | + | 31 | 45 | t1 | 9 |
| 1 | + | 52 | 90 | t1 | 23 |
| 2 | - | 101 | 130 | t2 | 17 |
| 2 | - | 201 | 218 | t2 | 0 |
+--------------+--------------+-----------+-----------+-----------------+-----------+
Stranded PyRanges object has 5 rows and 6 columns from 2 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
# Column to save the initial index
self.__index__ = np.arange(len(self))
# Filtering for desired columns
lst = by if type(by) is list else [by]
sorted_p = self[["Strand", "__index__"] + lst]
# Sorting by 5' (Intervals on + are sorted by ascending order and - are sorted by descending order)
sorted_p = sorted_p.sort(by="5")
# Creating a column saving the length for the intervals (for selenoprofiles and ensembl)
sorted_p.__length__ = sorted_p.End - sorted_p.Start
# Creating a column saving the cummulative length for the intervals
for k, df in sorted_p:
sorted_p.dfs[k]["__cumsum__"] = df.groupby(by=by, observed=False).__length__.cumsum()
# Creating a frame column
sorted_p.Frame = sorted_p.__cumsum__ - sorted_p.__length__
# Appending the Frame of sorted_p by the index of p
sorted_p = sorted_p.apply(lambda df: df.sort_values(by="__index__"))
self.Frame = sorted_p.Frame
# Drop __index__ column
self.apply(lambda df: df.drop("__index__", axis=1, inplace=True))
|
Calculate the frame of each genomic interval, assuming all are coding sequences (CDS), and add it as column inplace.
After this, the input Pyranges will contain an added "Frame" column, which determines the base of the CDS that is the first base of a codon.
Resulting values are in range between 0 and 2 included. 0 indicates that the first base of the CDS is the first base of a codon,
1 indicates the second base and 2 indicates the third base of the CDS.
While the 5'-most interval of each transcript has always 0 frame, the following ones may have any of these values.
Parameters
----------
by : str or list of str
Column(s) to group by the intervals: coding exons belonging to the same transcript have the same values in this/these column(s).
Returns
-------
None
The "Frame" column is added inplace.
Examples
--------
>>> p= pr.from_dict({"Chromosome": [1,1,1,2,2],
... "Strand": ["+","+","+","-","-"],
... "Start": [1,31,52,101,201],
... "End": [10,45,90,130,218],
... "transcript_id": ["t1","t1","t1","t2","t2"] })
>>> p
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 1 | 10 | t1 |
| 1 | + | 31 | 45 | t1 |
| 1 | + | 52 | 90 | t1 |
| 2 | - | 101 | 130 | t2 |
| 2 | - | 201 | 218 | t2 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 5 rows and 5 columns from 2 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> p.calculate_frame(by=['transcript_id'])
>>> p
+--------------+--------------+-----------+-----------+-----------------+-----------+
| Chromosome | Strand | Start | End | transcript_id | Frame |
| (category) | (category) | (int64) | (int64) | (object) | (int64) |
|--------------+--------------+-----------+-----------+-----------------+-----------|
| 1 | + | 1 | 10 | t1 | 0 |
| 1 | + | 31 | 45 | t1 | 9 |
| 1 | + | 52 | 90 | t1 | 23 |
| 2 | - | 101 | 130 | t2 | 17 |
| 2 | - | 201 | 218 | t2 | 0 |
+--------------+--------------+-----------+-----------+-----------------+-----------+
Stranded PyRanges object has 5 rows and 6 columns from 2 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
calculate_frame
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def cluster(self, strand=None, by=None, slack=0, count=False, nb_cpu=1):
"""Give overlapping intervals a common id.
Parameters
----------
strand : bool, default None, i.e. auto
Whether to ignore strand information if PyRanges is stranded.
by : str or list, default None
Only intervals with an equal value in column(s) `by` are clustered.
slack : int, default 0
Consider intervals separated by less than `slack` to be in the same cluster. If `slack`
is negative, intervals overlapping less than `slack` are not considered to be in the
same cluster.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
PyRanges
PyRanges with an ID-column "Cluster" added.
Warning
-------
Bookended intervals (i.e. the End of a PyRanges interval is the Start of
another one) are by default considered to overlap.
Avoid this with slack=-1.
See also
--------
PyRanges.merge: combine overlapping intervals into one
Examples
--------
>>> gr = pr.from_dict({"Chromosome": [1, 1, 1, 1], "Start": [1, 2, 3, 9],
... "End": [3, 3, 10, 12], "Gene": [1, 2, 3, 3]})
>>> gr
+--------------+-----------+-----------+-----------+
| Chromosome | Start | End | Gene |
| (category) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------|
| 1 | 1 | 3 | 1 |
| 1 | 2 | 3 | 2 |
| 1 | 3 | 10 | 3 |
| 1 | 9 | 12 | 3 |
+--------------+-----------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.cluster()
+--------------+-----------+-----------+-----------+-----------+
| Chromosome | Start | End | Gene | Cluster |
| (category) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------|
| 1 | 1 | 3 | 1 | 1 |
| 1 | 2 | 3 | 2 | 1 |
| 1 | 3 | 10 | 3 | 1 |
| 1 | 9 | 12 | 3 | 1 |
+--------------+-----------+-----------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.cluster(by="Gene", count=True)
+--------------+-----------+-----------+-----------+-----------+-----------+
| Chromosome | Start | End | Gene | Cluster | Count |
| (category) | (int64) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------+-----------|
| 1 | 1 | 3 | 1 | 1 | 1 |
| 1 | 2 | 3 | 2 | 2 | 1 |
| 1 | 3 | 10 | 3 | 3 | 2 |
| 1 | 9 | 12 | 3 | 3 | 2 |
+--------------+-----------+-----------+-----------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
Avoid clustering bookended intervals with slack=-1:
>>> gr.cluster(slack=-1)
+--------------+-----------+-----------+-----------+-----------+
| Chromosome | Start | End | Gene | Cluster |
| (category) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------|
| 1 | 1 | 3 | 1 | 1 |
| 1 | 2 | 3 | 2 | 1 |
| 1 | 3 | 10 | 3 | 2 |
| 1 | 9 | 12 | 3 | 2 |
+--------------+-----------+-----------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr2 = pr.data.ensembl_gtf()[["Feature", "Source"]]
>>> gr2.cluster(by=["Feature", "Source"])
+--------------+--------------+---------------+-----------+-----------+--------------+-----------+
| Chromosome | Feature | Source | Start | End | Strand | Cluster |
| (category) | (category) | (object) | (int64) | (int64) | (category) | (int64) |
|--------------+--------------+---------------+-----------+-----------+--------------+-----------|
| 1 | CDS | ensembl | 69090 | 70005 | + | 1 |
| 1 | CDS | ensembl | 925941 | 926013 | + | 2 |
| 1 | CDS | ensembl | 925941 | 926013 | + | 2 |
| 1 | CDS | ensembl | 925941 | 926013 | + | 2 |
| ... | ... | ... | ... | ... | ... | ... |
| 1 | transcript | havana_tagene | 167128 | 169240 | - | 1142 |
| 1 | transcript | mirbase | 17368 | 17436 | - | 1143 |
| 1 | transcript | mirbase | 187890 | 187958 | - | 1144 |
| 1 | transcript | mirbase | 632324 | 632413 | - | 1145 |
+--------------+--------------+---------------+-----------+-----------+--------------+-----------+
Stranded PyRanges object has 2,446 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
if strand is None:
strand = self.stranded
kwargs = {"strand": strand, "slack": slack, "count": count, "by": by}
kwargs = fill_kwargs(kwargs)
_stranded = self.stranded
if not strand and _stranded:
self.Strand2 = self.Strand
self = self.unstrand()
if not by:
from pyranges.methods.cluster import _cluster
df = pyrange_apply_single(_cluster, self, **kwargs)
else:
from pyranges.methods.cluster import _cluster_by
kwargs["by"] = by
df = pyrange_apply_single(_cluster_by, self, **kwargs)
gr = PyRanges(df)
# each chromosome got overlapping ids (0 to len). Need to make unique!
new_dfs = {}
first = True
max_id = 0
for k, v in gr.items():
if first:
max_id = v.Cluster.max()
new_dfs[k] = v
first = False
continue
v.loc[:, "Cluster"] += max_id
max_id = v.Cluster.max()
new_dfs[k] = v
if not strand and _stranded:
new_dfs = {k: d.rename(columns={"Strand2": "Strand"}) for k, d in new_dfs.items()}
self = PyRanges(new_dfs)
return self
|
Give overlapping intervals a common id.
Parameters
----------
strand : bool, default None, i.e. auto
Whether to ignore strand information if PyRanges is stranded.
by : str or list, default None
Only intervals with an equal value in column(s) `by` are clustered.
slack : int, default 0
Consider intervals separated by less than `slack` to be in the same cluster. If `slack`
is negative, intervals overlapping less than `slack` are not considered to be in the
same cluster.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
PyRanges
PyRanges with an ID-column "Cluster" added.
Warning
-------
Bookended intervals (i.e. the End of a PyRanges interval is the Start of
another one) are by default considered to overlap.
Avoid this with slack=-1.
See also
--------
PyRanges.merge: combine overlapping intervals into one
Examples
--------
>>> gr = pr.from_dict({"Chromosome": [1, 1, 1, 1], "Start": [1, 2, 3, 9],
... "End": [3, 3, 10, 12], "Gene": [1, 2, 3, 3]})
>>> gr
+--------------+-----------+-----------+-----------+
| Chromosome | Start | End | Gene |
| (category) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------|
| 1 | 1 | 3 | 1 |
| 1 | 2 | 3 | 2 |
| 1 | 3 | 10 | 3 |
| 1 | 9 | 12 | 3 |
+--------------+-----------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.cluster()
+--------------+-----------+-----------+-----------+-----------+
| Chromosome | Start | End | Gene | Cluster |
| (category) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------|
| 1 | 1 | 3 | 1 | 1 |
| 1 | 2 | 3 | 2 | 1 |
| 1 | 3 | 10 | 3 | 1 |
| 1 | 9 | 12 | 3 | 1 |
+--------------+-----------+-----------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.cluster(by="Gene", count=True)
+--------------+-----------+-----------+-----------+-----------+-----------+
| Chromosome | Start | End | Gene | Cluster | Count |
| (category) | (int64) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------+-----------|
| 1 | 1 | 3 | 1 | 1 | 1 |
| 1 | 2 | 3 | 2 | 2 | 1 |
| 1 | 3 | 10 | 3 | 3 | 2 |
| 1 | 9 | 12 | 3 | 3 | 2 |
+--------------+-----------+-----------+-----------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
Avoid clustering bookended intervals with slack=-1:
>>> gr.cluster(slack=-1)
+--------------+-----------+-----------+-----------+-----------+
| Chromosome | Start | End | Gene | Cluster |
| (category) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------|
| 1 | 1 | 3 | 1 | 1 |
| 1 | 2 | 3 | 2 | 1 |
| 1 | 3 | 10 | 3 | 2 |
| 1 | 9 | 12 | 3 | 2 |
+--------------+-----------+-----------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr2 = pr.data.ensembl_gtf()[["Feature", "Source"]]
>>> gr2.cluster(by=["Feature", "Source"])
+--------------+--------------+---------------+-----------+-----------+--------------+-----------+
| Chromosome | Feature | Source | Start | End | Strand | Cluster |
| (category) | (category) | (object) | (int64) | (int64) | (category) | (int64) |
|--------------+--------------+---------------+-----------+-----------+--------------+-----------|
| 1 | CDS | ensembl | 69090 | 70005 | + | 1 |
| 1 | CDS | ensembl | 925941 | 926013 | + | 2 |
| 1 | CDS | ensembl | 925941 | 926013 | + | 2 |
| 1 | CDS | ensembl | 925941 | 926013 | + | 2 |
| ... | ... | ... | ... | ... | ... | ... |
| 1 | transcript | havana_tagene | 167128 | 169240 | - | 1142 |
| 1 | transcript | mirbase | 17368 | 17436 | - | 1143 |
| 1 | transcript | mirbase | 187890 | 187958 | - | 1144 |
| 1 | transcript | mirbase | 632324 | 632413 | - | 1145 |
+--------------+--------------+---------------+-----------+-----------+--------------+-----------+
Stranded PyRanges object has 2,446 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
cluster
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def columns(self):
"""Return the column labels of the PyRanges.
Returns
-------
pandas.Index
See also
--------
PyRanges.chromosomes : return the chromosomes in the PyRanges
Examples
--------
>>> f2 = pr.data.f2()
>>> f2
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 1 | 2 | a | 0 | + |
| chr1 | 6 | 7 | b | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 2 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f2.columns
Index(['Chromosome', 'Start', 'End', 'Name', 'Score', 'Strand'], dtype='object')
>>> f2.columns = f2.columns.str.replace("Sco|re", "NYAN", regex=True)
>>> f2
+--------------+-----------+-----------+------------+------------+--------------+
| Chromosome | Start | End | Name | NYANNYAN | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+------------+--------------|
| chr1 | 1 | 2 | a | 0 | + |
| chr1 | 6 | 7 | b | 0 | - |
+--------------+-----------+-----------+------------+------------+--------------+
Stranded PyRanges object has 2 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
if not len(self.values()):
return []
first = next(iter(self.values()))
columns = first.columns
return columns
|
Return the column labels of the PyRanges.
Returns
-------
pandas.Index
See also
--------
PyRanges.chromosomes : return the chromosomes in the PyRanges
Examples
--------
>>> f2 = pr.data.f2()
>>> f2
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 1 | 2 | a | 0 | + |
| chr1 | 6 | 7 | b | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 2 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f2.columns
Index(['Chromosome', 'Start', 'End', 'Name', 'Score', 'Strand'], dtype='object')
>>> f2.columns = f2.columns.str.replace("Sco|re", "NYAN", regex=True)
>>> f2
+--------------+-----------+-----------+------------+------------+--------------+
| Chromosome | Start | End | Name | NYANNYAN | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+------------+--------------|
| chr1 | 1 | 2 | a | 0 | + |
| chr1 | 6 | 7 | b | 0 | - |
+--------------+-----------+-----------+------------+------------+--------------+
Stranded PyRanges object has 2 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
columns
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def count_overlaps(
self,
other,
strandedness=None,
keep_nonoverlapping=True,
overlap_col="NumberOverlaps",
):
"""Count number of overlaps per interval.
Count how many intervals in self overlap with those in other.
Parameters
----------
strandedness : {"same", "opposite", None, False}, default None, i.e. auto
Whether to perform the operation on the same, opposite or no strand. Use False to
ignore the strand. None means use "same" if both PyRanges are stranded, otherwise
ignore.
keep_nonoverlapping : bool, default True
Keep intervals without overlaps.
overlap_col : str, default "NumberOverlaps"
Name of column with overlap counts.
nb_cpu : int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
PyRanges
PyRanges with a column of overlaps added.
See also
--------
PyRanges.coverage: find coverage of PyRanges
pyranges.count_overlaps: count overlaps from multiple PyRanges
Examples
--------
>>> f1 = pr.data.f1().drop()
>>> f1
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 3 | 6 | + |
| chr1 | 8 | 9 | + |
| chr1 | 5 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f2 = pr.data.f2().drop()
>>> f2
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 1 | 2 | + |
| chr1 | 6 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f1.count_overlaps(f2, overlap_col="Count")
+--------------+-----------+-----------+--------------+-----------+
| Chromosome | Start | End | Strand | Count |
| (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------|
| chr1 | 3 | 6 | + | 0 |
| chr1 | 8 | 9 | + | 0 |
| chr1 | 5 | 7 | - | 1 |
+--------------+-----------+-----------+--------------+-----------+
Stranded PyRanges object has 3 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
kwargs = {
"strandedness": strandedness,
"keep_nonoverlapping": keep_nonoverlapping,
"overlap_col": overlap_col,
}
kwargs = fill_kwargs(kwargs)
from pyranges.methods.coverage import _number_overlapping
counts = pyrange_apply(_number_overlapping, self, other, **kwargs)
return pr.PyRanges(counts)
|
Count number of overlaps per interval.
Count how many intervals in self overlap with those in other.
Parameters
----------
strandedness : {"same", "opposite", None, False}, default None, i.e. auto
Whether to perform the operation on the same, opposite or no strand. Use False to
ignore the strand. None means use "same" if both PyRanges are stranded, otherwise
ignore.
keep_nonoverlapping : bool, default True
Keep intervals without overlaps.
overlap_col : str, default "NumberOverlaps"
Name of column with overlap counts.
nb_cpu : int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
PyRanges
PyRanges with a column of overlaps added.
See also
--------
PyRanges.coverage: find coverage of PyRanges
pyranges.count_overlaps: count overlaps from multiple PyRanges
Examples
--------
>>> f1 = pr.data.f1().drop()
>>> f1
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 3 | 6 | + |
| chr1 | 8 | 9 | + |
| chr1 | 5 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f2 = pr.data.f2().drop()
>>> f2
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 1 | 2 | + |
| chr1 | 6 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f1.count_overlaps(f2, overlap_col="Count")
+--------------+-----------+-----------+--------------+-----------+
| Chromosome | Start | End | Strand | Count |
| (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------|
| chr1 | 3 | 6 | + | 0 |
| chr1 | 8 | 9 | + | 0 |
| chr1 | 5 | 7 | - | 1 |
+--------------+-----------+-----------+--------------+-----------+
Stranded PyRanges object has 3 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
count_overlaps
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def coverage(
self,
other,
strandedness=None,
keep_nonoverlapping=True,
overlap_col="NumberOverlaps",
fraction_col="FractionOverlaps",
nb_cpu=1,
):
"""Count number of overlaps and their fraction per interval.
Count how many intervals in self overlap with those in other.
Parameters
----------
strandedness : {"same", "opposite", None, False}, default None, i.e. auto
Whether to perform the operation on the same, opposite or no strand. Use False to
ignore the strand. None means use "same" if both PyRanges are stranded, otherwise
ignore.
keep_nonoverlapping : bool, default True
Keep intervals without overlaps.
overlap_col : str, default "NumberOverlaps"
Name of column with overlap counts.
fraction_col : str, default "FractionOverlaps"
Name of column with fraction of counts.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
PyRanges
PyRanges with a column of overlaps added.
See also
--------
pyranges.count_overlaps: count overlaps from multiple PyRanges
Examples
--------
>>> f1 = pr.from_dict({"Chromosome": [1, 1, 1], "Start": [3, 8, 5],
... "End": [6, 9, 7]})
>>> f1
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| 1 | 3 | 6 |
| 1 | 8 | 9 |
| 1 | 5 | 7 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> f2 = pr.from_dict({"Chromosome": [1, 1], "Start": [1, 6],
... "End": [2, 7]})
>>> f2
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| 1 | 1 | 2 |
| 1 | 6 | 7 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> f1.coverage(f2, overlap_col="C", fraction_col="F")
+--------------+-----------+-----------+-----------+-------------+
| Chromosome | Start | End | C | F |
| (category) | (int64) | (int64) | (int64) | (float64) |
|--------------+-----------+-----------+-----------+-------------|
| 1 | 3 | 6 | 0 | 0 |
| 1 | 8 | 9 | 0 | 0 |
| 1 | 5 | 7 | 1 | 0.5 |
+--------------+-----------+-----------+-----------+-------------+
Unstranded PyRanges object has 3 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
"""
kwargs = {
"strandedness": strandedness,
"keep_nonoverlapping": keep_nonoverlapping,
"overlap_col": overlap_col,
"fraction_col": fraction_col,
"nb_cpu": nb_cpu,
}
kwargs = fill_kwargs(kwargs)
counts = self.count_overlaps(
other,
keep_nonoverlapping=True,
overlap_col=overlap_col,
strandedness=strandedness,
)
strand = True if kwargs["strandedness"] else False
other = other.merge(count=True, strand=strand)
from pyranges.methods.coverage import _coverage
counts = pr.PyRanges(pyrange_apply(_coverage, counts, other, **kwargs))
return counts
|
Count number of overlaps and their fraction per interval.
Count how many intervals in self overlap with those in other.
Parameters
----------
strandedness : {"same", "opposite", None, False}, default None, i.e. auto
Whether to perform the operation on the same, opposite or no strand. Use False to
ignore the strand. None means use "same" if both PyRanges are stranded, otherwise
ignore.
keep_nonoverlapping : bool, default True
Keep intervals without overlaps.
overlap_col : str, default "NumberOverlaps"
Name of column with overlap counts.
fraction_col : str, default "FractionOverlaps"
Name of column with fraction of counts.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
PyRanges
PyRanges with a column of overlaps added.
See also
--------
pyranges.count_overlaps: count overlaps from multiple PyRanges
Examples
--------
>>> f1 = pr.from_dict({"Chromosome": [1, 1, 1], "Start": [3, 8, 5],
... "End": [6, 9, 7]})
>>> f1
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| 1 | 3 | 6 |
| 1 | 8 | 9 |
| 1 | 5 | 7 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> f2 = pr.from_dict({"Chromosome": [1, 1], "Start": [1, 6],
... "End": [2, 7]})
>>> f2
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| 1 | 1 | 2 |
| 1 | 6 | 7 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> f1.coverage(f2, overlap_col="C", fraction_col="F")
+--------------+-----------+-----------+-----------+-------------+
| Chromosome | Start | End | C | F |
| (category) | (int64) | (int64) | (int64) | (float64) |
|--------------+-----------+-----------+-----------+-------------|
| 1 | 3 | 6 | 0 | 0 |
| 1 | 8 | 9 | 0 | 0 |
| 1 | 5 | 7 | 1 | 0.5 |
+--------------+-----------+-----------+-----------+-------------+
Unstranded PyRanges object has 3 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
|
coverage
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def drop(self, drop=None, like=None):
"""Drop column(s).
If no arguments are given, all the columns except Chromosome, Start, End and Strand are
dropped.
Parameters
----------
drop : str or list, default None
Columns to drop.
like : str, default None
Regex-string matching columns to drop. Matches with Chromosome, Start, End or Strand
are ignored.
See also
--------
PyRanges.unstrand : drop strand information
Examples
--------
>>> gr = pr.from_dict({"Chromosome": [1, 1], "Start": [1, 4], "End": [5, 6],
... "Strand": ["+", "-"], "Count": [1, 2],
... "Type": ["exon", "exon"]})
>>> gr
+--------------+-----------+-----------+--------------+-----------+------------+
| Chromosome | Start | End | Strand | Count | Type |
| (category) | (int64) | (int64) | (category) | (int64) | (object) |
|--------------+-----------+-----------+--------------+-----------+------------|
| 1 | 1 | 5 | + | 1 | exon |
| 1 | 4 | 6 | - | 2 | exon |
+--------------+-----------+-----------+--------------+-----------+------------+
Stranded PyRanges object has 2 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.drop()
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| 1 | 1 | 5 | + |
| 1 | 4 | 6 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
Matches with position-columns are ignored:
>>> gr.drop(like="Chromosome|Strand")
+--------------+-----------+-----------+--------------+-----------+------------+
| Chromosome | Start | End | Strand | Count | Type |
| (category) | (int64) | (int64) | (category) | (int64) | (object) |
|--------------+-----------+-----------+--------------+-----------+------------|
| 1 | 1 | 5 | + | 1 | exon |
| 1 | 4 | 6 | - | 2 | exon |
+--------------+-----------+-----------+--------------+-----------+------------+
Stranded PyRanges object has 2 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.drop(like="e$")
+--------------+-----------+-----------+--------------+-----------+
| Chromosome | Start | End | Strand | Count |
| (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------|
| 1 | 1 | 5 | + | 1 |
| 1 | 4 | 6 | - | 2 |
+--------------+-----------+-----------+--------------+-----------+
Stranded PyRanges object has 2 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
from pyranges.methods.drop import _drop
return _drop(self, drop, like)
|
Drop column(s).
If no arguments are given, all the columns except Chromosome, Start, End and Strand are
dropped.
Parameters
----------
drop : str or list, default None
Columns to drop.
like : str, default None
Regex-string matching columns to drop. Matches with Chromosome, Start, End or Strand
are ignored.
See also
--------
PyRanges.unstrand : drop strand information
Examples
--------
>>> gr = pr.from_dict({"Chromosome": [1, 1], "Start": [1, 4], "End": [5, 6],
... "Strand": ["+", "-"], "Count": [1, 2],
... "Type": ["exon", "exon"]})
>>> gr
+--------------+-----------+-----------+--------------+-----------+------------+
| Chromosome | Start | End | Strand | Count | Type |
| (category) | (int64) | (int64) | (category) | (int64) | (object) |
|--------------+-----------+-----------+--------------+-----------+------------|
| 1 | 1 | 5 | + | 1 | exon |
| 1 | 4 | 6 | - | 2 | exon |
+--------------+-----------+-----------+--------------+-----------+------------+
Stranded PyRanges object has 2 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.drop()
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| 1 | 1 | 5 | + |
| 1 | 4 | 6 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
Matches with position-columns are ignored:
>>> gr.drop(like="Chromosome|Strand")
+--------------+-----------+-----------+--------------+-----------+------------+
| Chromosome | Start | End | Strand | Count | Type |
| (category) | (int64) | (int64) | (category) | (int64) | (object) |
|--------------+-----------+-----------+--------------+-----------+------------|
| 1 | 1 | 5 | + | 1 | exon |
| 1 | 4 | 6 | - | 2 | exon |
+--------------+-----------+-----------+--------------+-----------+------------+
Stranded PyRanges object has 2 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.drop(like="e$")
+--------------+-----------+-----------+--------------+-----------+
| Chromosome | Start | End | Strand | Count |
| (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------|
| 1 | 1 | 5 | + | 1 |
| 1 | 4 | 6 | - | 2 |
+--------------+-----------+-----------+--------------+-----------+
Stranded PyRanges object has 2 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
drop
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def drop_duplicate_positions(self, strand=None, keep="first"):
"""Return PyRanges with duplicate postion rows removed.
Parameters
----------
strand : bool, default None, i.e. auto
Whether to take strand-information into account when considering duplicates.
keep : {"first", "last", False}
Whether to keep first, last or drop all duplicates.
Examples
--------
>>> gr = pr.from_string('''Chromosome Start End Strand Name
... 1 1 2 + A
... 1 1 2 - B
... 1 1 2 + Z''')
>>> gr
+--------------+-----------+-----------+--------------+------------+
| Chromosome | Start | End | Strand | Name |
| (category) | (int64) | (int64) | (category) | (object) |
|--------------+-----------+-----------+--------------+------------|
| 1 | 1 | 2 | + | A |
| 1 | 1 | 2 | + | Z |
| 1 | 1 | 2 | - | B |
+--------------+-----------+-----------+--------------+------------+
Stranded PyRanges object has 3 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.drop_duplicate_positions()
+--------------+-----------+-----------+--------------+------------+
| Chromosome | Start | End | Strand | Name |
| (category) | (int64) | (int64) | (category) | (object) |
|--------------+-----------+-----------+--------------+------------|
| 1 | 1 | 2 | + | A |
| 1 | 1 | 2 | - | B |
+--------------+-----------+-----------+--------------+------------+
Stranded PyRanges object has 2 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.drop_duplicate_positions(keep="last")
+--------------+-----------+-----------+--------------+------------+
| Chromosome | Start | End | Strand | Name |
| (category) | (int64) | (int64) | (category) | (object) |
|--------------+-----------+-----------+--------------+------------|
| 1 | 1 | 2 | + | Z |
| 1 | 1 | 2 | - | B |
+--------------+-----------+-----------+--------------+------------+
Stranded PyRanges object has 2 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
Note that the reverse strand is considered to be behind the forward strand:
>>> gr.drop_duplicate_positions(keep="last", strand=False)
+--------------+-----------+-----------+--------------+------------+
| Chromosome | Start | End | Strand | Name |
| (category) | (int64) | (int64) | (category) | (object) |
|--------------+-----------+-----------+--------------+------------|
| 1 | 1 | 2 | - | B |
+--------------+-----------+-----------+--------------+------------+
Stranded PyRanges object has 1 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.drop_duplicate_positions(keep=False, strand=False)
Empty PyRanges
"""
from pyranges.methods.drop_duplicates import _drop_duplicate_positions
if strand is None:
strand = self.stranded
kwargs = {}
kwargs["sparse"] = {"self": False}
kwargs["keep"] = keep
kwargs = fill_kwargs(kwargs)
kwargs["strand"] = strand and self.stranded
return PyRanges(pyrange_apply_single(_drop_duplicate_positions, self, **kwargs))
|
Return PyRanges with duplicate postion rows removed.
Parameters
----------
strand : bool, default None, i.e. auto
Whether to take strand-information into account when considering duplicates.
keep : {"first", "last", False}
Whether to keep first, last or drop all duplicates.
Examples
--------
>>> gr = pr.from_string('''Chromosome Start End Strand Name
... 1 1 2 + A
... 1 1 2 - B
... 1 1 2 + Z''')
>>> gr
+--------------+-----------+-----------+--------------+------------+
| Chromosome | Start | End | Strand | Name |
| (category) | (int64) | (int64) | (category) | (object) |
|--------------+-----------+-----------+--------------+------------|
| 1 | 1 | 2 | + | A |
| 1 | 1 | 2 | + | Z |
| 1 | 1 | 2 | - | B |
+--------------+-----------+-----------+--------------+------------+
Stranded PyRanges object has 3 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.drop_duplicate_positions()
+--------------+-----------+-----------+--------------+------------+
| Chromosome | Start | End | Strand | Name |
| (category) | (int64) | (int64) | (category) | (object) |
|--------------+-----------+-----------+--------------+------------|
| 1 | 1 | 2 | + | A |
| 1 | 1 | 2 | - | B |
+--------------+-----------+-----------+--------------+------------+
Stranded PyRanges object has 2 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.drop_duplicate_positions(keep="last")
+--------------+-----------+-----------+--------------+------------+
| Chromosome | Start | End | Strand | Name |
| (category) | (int64) | (int64) | (category) | (object) |
|--------------+-----------+-----------+--------------+------------|
| 1 | 1 | 2 | + | Z |
| 1 | 1 | 2 | - | B |
+--------------+-----------+-----------+--------------+------------+
Stranded PyRanges object has 2 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
Note that the reverse strand is considered to be behind the forward strand:
>>> gr.drop_duplicate_positions(keep="last", strand=False)
+--------------+-----------+-----------+--------------+------------+
| Chromosome | Start | End | Strand | Name |
| (category) | (int64) | (int64) | (category) | (object) |
|--------------+-----------+-----------+--------------+------------|
| 1 | 1 | 2 | - | B |
+--------------+-----------+-----------+--------------+------------+
Stranded PyRanges object has 1 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.drop_duplicate_positions(keep=False, strand=False)
Empty PyRanges
|
drop_duplicate_positions
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def extend(self, ext, group_by=None):
"""Extend the intervals from the ends.
Parameters
----------
ext : int or dict of ints with "3" and/or "5" as keys.
The number of nucleotides to extend the ends with.
If an int is provided, the same extension is applied to both
the start and end of intervals, while a dict input allows to control
differently the two ends. Note also that 5' and 3' extensions take
the strand into account, if the intervals are stranded.
group_by : str or list of str, default: None
group intervals by these column name(s), so that the extension is applied
only to the left-most and/or right-most interval.
See Also
--------
PyRanges.subsequence : obtain subsequences of intervals
PyRanges.spliced_subsequence : obtain subsequences of intervals, providing transcript-level coordinates
Examples
--------
>>> d = {'Chromosome': ['chr1', 'chr1', 'chr1'], 'Start': [3, 8, 5], 'End': [6, 9, 7],
... 'Strand': ['+', '+', '-']}
>>> gr = pr.from_dict(d)
>>> gr
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 3 | 6 | + |
| chr1 | 8 | 9 | + |
| chr1 | 5 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.extend(4)
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 0 | 10 | + |
| chr1 | 4 | 13 | + |
| chr1 | 1 | 11 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.extend({"3": 1})
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 3 | 7 | + |
| chr1 | 8 | 10 | + |
| chr1 | 4 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.extend({"3": 1, "5": 2})
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 1 | 7 | + |
| chr1 | 6 | 10 | + |
| chr1 | 4 | 9 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.extend(-1)
Traceback (most recent call last):
...
AssertionError: Some intervals are negative or zero length after applying extend!
"""
if isinstance(ext, dict):
assert self.stranded, "PyRanges must be stranded to add 5/3-end specific extend."
kwargs = fill_kwargs({"ext": ext, "strand": self.stranded})
if group_by is None:
prg = PyRanges(pyrange_apply_single(_extend, self, **kwargs))
else:
kwargs["group_by"] = group_by
prg = PyRanges(pyrange_apply_single(_extend_grp, self, **kwargs))
return prg
|
Extend the intervals from the ends.
Parameters
----------
ext : int or dict of ints with "3" and/or "5" as keys.
The number of nucleotides to extend the ends with.
If an int is provided, the same extension is applied to both
the start and end of intervals, while a dict input allows to control
differently the two ends. Note also that 5' and 3' extensions take
the strand into account, if the intervals are stranded.
group_by : str or list of str, default: None
group intervals by these column name(s), so that the extension is applied
only to the left-most and/or right-most interval.
See Also
--------
PyRanges.subsequence : obtain subsequences of intervals
PyRanges.spliced_subsequence : obtain subsequences of intervals, providing transcript-level coordinates
Examples
--------
>>> d = {'Chromosome': ['chr1', 'chr1', 'chr1'], 'Start': [3, 8, 5], 'End': [6, 9, 7],
... 'Strand': ['+', '+', '-']}
>>> gr = pr.from_dict(d)
>>> gr
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 3 | 6 | + |
| chr1 | 8 | 9 | + |
| chr1 | 5 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.extend(4)
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 0 | 10 | + |
| chr1 | 4 | 13 | + |
| chr1 | 1 | 11 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.extend({"3": 1})
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 3 | 7 | + |
| chr1 | 8 | 10 | + |
| chr1 | 4 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.extend({"3": 1, "5": 2})
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 1 | 7 | + |
| chr1 | 6 | 10 | + |
| chr1 | 4 | 9 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.extend(-1)
Traceback (most recent call last):
...
AssertionError: Some intervals are negative or zero length after applying extend!
|
extend
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def five_end(self):
"""Return the five prime end of intervals.
The five prime end is the start of a forward strand or the end of a reverse strand.
Returns
-------
PyRanges
PyRanges with the five prime ends
Notes
-----
Requires the PyRanges to be stranded.
See Also
--------
PyRanges.three_end : return the 3' end
Examples
--------
>>> gr = pr.from_dict({'Chromosome': ['chr1', 'chr1'], 'Start': [3, 5], 'End': [9, 7],
... 'Strand': ["+", "-"]})
>>> gr
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 3 | 9 | + |
| chr1 | 5 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.five_end()
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 3 | 4 | + |
| chr1 | 6 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
assert self.stranded, "Need stranded pyrange to find 5'."
kwargs = fill_kwargs({"strand": self.stranded})
return PyRanges(pyrange_apply_single(_tss, self, **kwargs))
|
Return the five prime end of intervals.
The five prime end is the start of a forward strand or the end of a reverse strand.
Returns
-------
PyRanges
PyRanges with the five prime ends
Notes
-----
Requires the PyRanges to be stranded.
See Also
--------
PyRanges.three_end : return the 3' end
Examples
--------
>>> gr = pr.from_dict({'Chromosome': ['chr1', 'chr1'], 'Start': [3, 5], 'End': [9, 7],
... 'Strand': ["+", "-"]})
>>> gr
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 3 | 9 | + |
| chr1 | 5 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.five_end()
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 3 | 4 | + |
| chr1 | 6 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
five_end
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def head(self, n=8):
"""Return the n first rows.
Parameters
----------
n : int, default 8
Return n rows.
Returns
-------
PyRanges
PyRanges with the n first rows.
See Also
--------
PyRanges.tail : return the last rows
PyRanges.sample : return random rows
Examples
--------
>>> gr = pr.data.chipseq()
>>> gr
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 212609534 | 212609559 | U0 | 0 | + |
| chr1 | 169887529 | 169887554 | U0 | 0 | + |
| chr1 | 216711011 | 216711036 | U0 | 0 | + |
| chr1 | 144227079 | 144227104 | U0 | 0 | + |
| ... | ... | ... | ... | ... | ... |
| chrY | 15224235 | 15224260 | U0 | 0 | - |
| chrY | 13517892 | 13517917 | U0 | 0 | - |
| chrY | 8010951 | 8010976 | U0 | 0 | - |
| chrY | 7405376 | 7405401 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 10,000 rows and 6 columns from 24 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.head(3)
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 212609534 | 212609559 | U0 | 0 | + |
| chr1 | 169887529 | 169887554 | U0 | 0 | + |
| chr1 | 216711011 | 216711036 | U0 | 0 | + |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 3 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
subsetter = np.zeros(len(self), dtype=np.bool_)
subsetter[:n] = True
return self[subsetter]
|
Return the n first rows.
Parameters
----------
n : int, default 8
Return n rows.
Returns
-------
PyRanges
PyRanges with the n first rows.
See Also
--------
PyRanges.tail : return the last rows
PyRanges.sample : return random rows
Examples
--------
>>> gr = pr.data.chipseq()
>>> gr
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 212609534 | 212609559 | U0 | 0 | + |
| chr1 | 169887529 | 169887554 | U0 | 0 | + |
| chr1 | 216711011 | 216711036 | U0 | 0 | + |
| chr1 | 144227079 | 144227104 | U0 | 0 | + |
| ... | ... | ... | ... | ... | ... |
| chrY | 15224235 | 15224260 | U0 | 0 | - |
| chrY | 13517892 | 13517917 | U0 | 0 | - |
| chrY | 8010951 | 8010976 | U0 | 0 | - |
| chrY | 7405376 | 7405401 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 10,000 rows and 6 columns from 24 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.head(3)
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 212609534 | 212609559 | U0 | 0 | + |
| chr1 | 169887529 | 169887554 | U0 | 0 | + |
| chr1 | 216711011 | 216711036 | U0 | 0 | + |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 3 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
head
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def insert(self, other, loc=None):
"""Add one or more columns to the PyRanges.
Parameters
----------
other : Series, DataFrame or dict
Data to insert into the PyRanges. `other` must have the same number of rows as the PyRanges.
loc : int, default None, i.e. after last column of PyRanges.
Insertion index.
Returns
-------
PyRanges
A copy of the PyRanges with the column(s) inserted starting at `loc`.
Note
----
If a Series, or a dict of Series is used, the Series must have a name.
Examples
--------
>>> gr = pr.from_dict({"Chromosome": ["L", "E", "E", "T"], "Start": [1, 1, 2, 3], "End": [5, 8, 13, 21]})
>>> gr
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| E | 1 | 8 |
| E | 2 | 13 |
| L | 1 | 5 |
| T | 3 | 21 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 3 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> s = pd.Series(data = [1, 3, 3, 7], name="Column")
>>> gr.insert(s)
+--------------+-----------+-----------+-----------+
| Chromosome | Start | End | Column |
| (category) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------|
| E | 1 | 8 | 1 |
| E | 2 | 13 | 3 |
| L | 1 | 5 | 3 |
| T | 3 | 21 | 7 |
+--------------+-----------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 4 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> df = pd.DataFrame({"NY": s, "AN": s})
>>> df
NY AN
0 1 1
1 3 3
2 3 3
3 7 7
Note that the original PyRanges was not affected by previously inserting Column:
>>> gr.insert(df, 1)
+--------------+-----------+-----------+-----------+-----------+
| Chromosome | NY | AN | Start | End |
| (category) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------|
| E | 1 | 1 | 1 | 8 |
| E | 3 | 3 | 2 | 13 |
| L | 3 | 3 | 1 | 5 |
| T | 7 | 7 | 3 | 21 |
+--------------+-----------+-----------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 5 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> arbitrary_result = gr.apply(
... lambda df: pd.Series(df.Start + df.End, name="Hi!"), as_pyranges=False)
>>> arbitrary_result
{'E': 1 9
2 15
Name: Hi!, dtype: int64, 'L': 0 6
Name: Hi!, dtype: int64, 'T': 3 24
Name: Hi!, dtype: int64}
>>> gr.insert(arbitrary_result)
+--------------+-----------+-----------+-----------+
| Chromosome | Start | End | Hi! |
| (category) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------|
| E | 1 | 8 | 9 |
| E | 2 | 13 | 15 |
| L | 1 | 5 | 6 |
| T | 3 | 21 | 24 |
+--------------+-----------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 4 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
"""
if loc is None:
loc = len(self.columns)
self = self.copy()
from pyranges.methods.attr import _setattr
if isinstance(other, (pd.Series, pd.DataFrame)):
assert len(other) == len(self), "Pandas Series or DataFrame must be same length as PyRanges!"
if isinstance(other, pd.Series):
if not other.name:
raise Exception("Series must have a name!")
_setattr(self, other.name, other, loc)
if isinstance(other, pd.DataFrame):
for c in other:
_setattr(self, c, other[c], loc)
loc += 1
elif isinstance(other, dict) and other:
first = next(iter(other.values()))
is_dataframe = isinstance(first, pd.DataFrame)
if is_dataframe:
columns = first.columns
ds = []
for c in columns:
ds.append({k: v[c] for k, v in other.items()})
for c, d in zip(columns, ds):
_setattr(self, str(c), d, loc)
loc += 1
else:
if not first.name:
raise Exception("Series must have a name!")
d = {k: v for k, v in other.items()}
_setattr(self, first.name, d, loc)
return self
|
Add one or more columns to the PyRanges.
Parameters
----------
other : Series, DataFrame or dict
Data to insert into the PyRanges. `other` must have the same number of rows as the PyRanges.
loc : int, default None, i.e. after last column of PyRanges.
Insertion index.
Returns
-------
PyRanges
A copy of the PyRanges with the column(s) inserted starting at `loc`.
Note
----
If a Series, or a dict of Series is used, the Series must have a name.
Examples
--------
>>> gr = pr.from_dict({"Chromosome": ["L", "E", "E", "T"], "Start": [1, 1, 2, 3], "End": [5, 8, 13, 21]})
>>> gr
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| E | 1 | 8 |
| E | 2 | 13 |
| L | 1 | 5 |
| T | 3 | 21 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 3 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> s = pd.Series(data = [1, 3, 3, 7], name="Column")
>>> gr.insert(s)
+--------------+-----------+-----------+-----------+
| Chromosome | Start | End | Column |
| (category) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------|
| E | 1 | 8 | 1 |
| E | 2 | 13 | 3 |
| L | 1 | 5 | 3 |
| T | 3 | 21 | 7 |
+--------------+-----------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 4 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> df = pd.DataFrame({"NY": s, "AN": s})
>>> df
NY AN
0 1 1
1 3 3
2 3 3
3 7 7
Note that the original PyRanges was not affected by previously inserting Column:
>>> gr.insert(df, 1)
+--------------+-----------+-----------+-----------+-----------+
| Chromosome | NY | AN | Start | End |
| (category) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------|
| E | 1 | 1 | 1 | 8 |
| E | 3 | 3 | 2 | 13 |
| L | 3 | 3 | 1 | 5 |
| T | 7 | 7 | 3 | 21 |
+--------------+-----------+-----------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 5 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> arbitrary_result = gr.apply(
... lambda df: pd.Series(df.Start + df.End, name="Hi!"), as_pyranges=False)
>>> arbitrary_result
{'E': 1 9
2 15
Name: Hi!, dtype: int64, 'L': 0 6
Name: Hi!, dtype: int64, 'T': 3 24
Name: Hi!, dtype: int64}
>>> gr.insert(arbitrary_result)
+--------------+-----------+-----------+-----------+
| Chromosome | Start | End | Hi! |
| (category) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------|
| E | 1 | 8 | 9 |
| E | 2 | 13 | 15 |
| L | 1 | 5 | 6 |
| T | 3 | 21 | 24 |
+--------------+-----------+-----------+-----------+
Unstranded PyRanges object has 4 rows and 4 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
|
insert
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def intersect(self, other, strandedness=None, how=None, invert=False, nb_cpu=1):
"""Return overlapping subintervals.
Returns the segments of the intervals in self which overlap with those in other.
Parameters
----------
other : PyRanges
PyRanges to intersect.
strandedness : {None, "same", "opposite", False}, default None, i.e. auto
Whether to compare PyRanges on the same strand, the opposite or ignore strand
information. The default, None, means use "same" if both PyRanges are strande,
otherwise ignore the strand information.
how : {None, "first", "last", "containment"}, default None, i.e. all
What intervals to report. By default reports all overlapping intervals. "containment"
reports intervals where the overlapping is contained within it.
invert : bool, default False
Whether to return the intervals without overlaps.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
PyRanges
A PyRanges with overlapping subintervals.
See also
--------
PyRanges.set_intersect : set-intersect PyRanges
PyRanges.overlap : report overlapping intervals
Examples
--------
>>> gr = pr.from_dict({"Chromosome": ["chr1"] * 3, "Start": [1, 4, 10],
... "End": [3, 9, 11], "ID": ["a", "b", "c"]})
>>> gr
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 1 | 3 | a |
| chr1 | 4 | 9 | b |
| chr1 | 10 | 11 | c |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr2 = pr.from_dict({"Chromosome": ["chr1"] * 3, "Start": [2, 2, 9], "End": [3, 9, 10]})
>>> gr2
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 2 | 3 |
| chr1 | 2 | 9 |
| chr1 | 9 | 10 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.intersect(gr2)
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 2 | 3 | a |
| chr1 | 2 | 3 | a |
| chr1 | 4 | 9 | b |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.intersect(gr2, how="first")
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 2 | 3 | a |
| chr1 | 4 | 9 | b |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.intersect(gr2, how="containment")
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 4 | 9 | b |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 1 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
"""
kwargs = {"how": how, "strandedness": strandedness, "nb_cpu": nb_cpu}
kwargs = fill_kwargs(kwargs)
kwargs["sparse"] = {"self": False, "other": True}
if len(self) == 0:
return self
if invert:
self.__ix__ = np.arange(len(self))
dfs = pyrange_apply(_intersection, self, other, **kwargs)
result = pr.PyRanges(dfs)
if invert:
found_idxs = getattr(result, "__ix__", [])
result = self[~self.__ix__.isin(found_idxs)]
result = result.drop("__ix__")
return result
|
Return overlapping subintervals.
Returns the segments of the intervals in self which overlap with those in other.
Parameters
----------
other : PyRanges
PyRanges to intersect.
strandedness : {None, "same", "opposite", False}, default None, i.e. auto
Whether to compare PyRanges on the same strand, the opposite or ignore strand
information. The default, None, means use "same" if both PyRanges are strande,
otherwise ignore the strand information.
how : {None, "first", "last", "containment"}, default None, i.e. all
What intervals to report. By default reports all overlapping intervals. "containment"
reports intervals where the overlapping is contained within it.
invert : bool, default False
Whether to return the intervals without overlaps.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
PyRanges
A PyRanges with overlapping subintervals.
See also
--------
PyRanges.set_intersect : set-intersect PyRanges
PyRanges.overlap : report overlapping intervals
Examples
--------
>>> gr = pr.from_dict({"Chromosome": ["chr1"] * 3, "Start": [1, 4, 10],
... "End": [3, 9, 11], "ID": ["a", "b", "c"]})
>>> gr
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 1 | 3 | a |
| chr1 | 4 | 9 | b |
| chr1 | 10 | 11 | c |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr2 = pr.from_dict({"Chromosome": ["chr1"] * 3, "Start": [2, 2, 9], "End": [3, 9, 10]})
>>> gr2
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 2 | 3 |
| chr1 | 2 | 9 |
| chr1 | 9 | 10 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.intersect(gr2)
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 2 | 3 | a |
| chr1 | 2 | 3 | a |
| chr1 | 4 | 9 | b |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.intersect(gr2, how="first")
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 2 | 3 | a |
| chr1 | 4 | 9 | b |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.intersect(gr2, how="containment")
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 4 | 9 | b |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 1 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
|
intersect
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def join(
self,
other,
strandedness=None,
how=None,
report_overlap=False,
slack=0,
suffix="_b",
nb_cpu=1,
apply_strand_suffix=None,
preserve_order=False,
):
"""Join PyRanges on genomic location.
Parameters
----------
other : PyRanges
PyRanges to join.
strandedness : {None, "same", "opposite", False}, default None, i.e. auto
Whether to compare PyRanges on the same strand, the opposite or ignore strand
information. The default, None, means use "same" if both PyRanges are strande,
otherwise ignore the strand information.
how : {None, "left", "right"}, default None, i.e. "inner"
How to handle intervals without overlap. None means only keep overlapping intervals.
"left" keeps all intervals in self, "right" keeps all intervals in other.
report_overlap : bool, default False
Report amount of overlap in base pairs.
slack : int, default 0
Lengthen intervals in self before joining.
suffix : str or tuple, default "_b"
Suffix to give overlapping columns in other.
apply_strand_suffix : bool, default None
If first pyranges is unstranded, but the second is not, the first will be given a strand column.
apply_strand_suffix makes the added strand column a regular data column instead by adding a suffix.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
preserve_order : bool, default False
If True, preserves the order after performing the join (only relevant in "outer", "left" and "right" joins).
Returns
-------
PyRanges
A PyRanges appended with columns of another.
Notes
-----
The chromosome from other will never be reported as it is always the same as in self.
As pandas did not have NaN for non-float datatypes until recently, "left" and "right" join
give non-overlapping rows the value -1 to avoid promoting columns to object. This will
change to NaN in a future version as general NaN becomes stable in pandas.
See also
--------
PyRanges.new_position : give joined PyRanges new coordinates
Examples
--------
>>> f1 = pr.from_dict({'Chromosome': ['chr1', 'chr1', 'chr1'], 'Start': [3, 8, 5],
... 'End': [6, 9, 7], 'Name': ['interval1', 'interval3', 'interval2']})
>>> f1
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | Name |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 3 | 6 | interval1 |
| chr1 | 8 | 9 | interval3 |
| chr1 | 5 | 7 | interval2 |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> f2 = pr.from_dict({'Chromosome': ['chr1', 'chr1'], 'Start': [1, 6],
... 'End': [2, 7], 'Name': ['a', 'b']})
>>> f2
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | Name |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 1 | 2 | a |
| chr1 | 6 | 7 | b |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> f1.join(f2)
+--------------+-----------+-----------+------------+-----------+-----------+------------+
| Chromosome | Start | End | Name | Start_b | End_b | Name_b |
| (category) | (int64) | (int64) | (object) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------+-----------+-----------+------------|
| chr1 | 5 | 7 | interval2 | 6 | 7 | b |
+--------------+-----------+-----------+------------+-----------+-----------+------------+
Unstranded PyRanges object has 1 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> f1.join(f2, how="right")
+--------------+-----------+-----------+------------+-----------+-----------+------------+
| Chromosome | Start | End | Name | Start_b | End_b | Name_b |
| (category) | (int64) | (int64) | (object) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------+-----------+-----------+------------|
| chr1 | 5 | 7 | interval2 | 6 | 7 | b |
| chr1 | -1 | -1 | -1 | 1 | 2 | a |
+--------------+-----------+-----------+------------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
With slack 1, bookended features are joined (see row 1):
>>> f1.join(f2, slack=1)
+--------------+-----------+-----------+------------+-----------+-----------+------------+
| Chromosome | Start | End | Name | Start_b | End_b | Name_b |
| (category) | (int64) | (int64) | (object) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------+-----------+-----------+------------|
| chr1 | 3 | 6 | interval1 | 6 | 7 | b |
| chr1 | 5 | 7 | interval2 | 6 | 7 | b |
+--------------+-----------+-----------+------------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> f1.join(f2, how="right", preserve_order=True)
+--------------+-----------+-----------+------------+-----------+-----------+------------+
| Chromosome | Start | End | Name | Start_b | End_b | Name_b |
| (category) | (int64) | (int64) | (object) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------+-----------+-----------+------------|
| chr1 | -1 | -1 | -1 | 1 | 2 | a |
| chr1 | 5 | 7 | interval2 | 6 | 7 | b |
+--------------+-----------+-----------+------------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
"""
from pyranges.methods.join import _write_both
kwargs = {
"strandedness": strandedness,
"how": how,
"report_overlap": report_overlap,
"suffix": suffix,
"nb_cpu": nb_cpu,
"apply_strand_suffix": apply_strand_suffix,
"preserve_order": preserve_order,
}
if slack:
self = self.copy()
self.Start__slack = self.Start
self.End__slack = self.End
self = self.extend(slack)
if "suffix" in kwargs and isinstance(kwargs["suffix"], str):
suffixes = "", kwargs["suffix"]
kwargs["suffixes"] = suffixes
kwargs = fill_kwargs(kwargs)
how = kwargs.get("how")
if how in ["left", "outer"]:
kwargs["example_header_other"] = other.head(1).df
if how in ["right", "outer"]:
kwargs["example_header_self"] = self.head(1).df
dfs = pyrange_apply(_write_both, self, other, **kwargs)
gr = PyRanges(dfs)
if slack and len(gr) > 0:
gr.Start = gr.Start__slack
gr.End = gr.End__slack
gr = gr.drop(like="(Start|End).*__slack")
if not self.stranded and other.stranded:
if apply_strand_suffix is None:
import sys
print(
"join: Strand data from other will be added as strand data to self.\nIf this is undesired use the flag apply_strand_suffix=False.\nTo turn off the warning set apply_strand_suffix to True or False.",
file=sys.stderr,
)
elif apply_strand_suffix:
gr.columns = gr.columns.str.replace("Strand", "Strand" + kwargs["suffix"])
return gr
|
Join PyRanges on genomic location.
Parameters
----------
other : PyRanges
PyRanges to join.
strandedness : {None, "same", "opposite", False}, default None, i.e. auto
Whether to compare PyRanges on the same strand, the opposite or ignore strand
information. The default, None, means use "same" if both PyRanges are strande,
otherwise ignore the strand information.
how : {None, "left", "right"}, default None, i.e. "inner"
How to handle intervals without overlap. None means only keep overlapping intervals.
"left" keeps all intervals in self, "right" keeps all intervals in other.
report_overlap : bool, default False
Report amount of overlap in base pairs.
slack : int, default 0
Lengthen intervals in self before joining.
suffix : str or tuple, default "_b"
Suffix to give overlapping columns in other.
apply_strand_suffix : bool, default None
If first pyranges is unstranded, but the second is not, the first will be given a strand column.
apply_strand_suffix makes the added strand column a regular data column instead by adding a suffix.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
preserve_order : bool, default False
If True, preserves the order after performing the join (only relevant in "outer", "left" and "right" joins).
Returns
-------
PyRanges
A PyRanges appended with columns of another.
Notes
-----
The chromosome from other will never be reported as it is always the same as in self.
As pandas did not have NaN for non-float datatypes until recently, "left" and "right" join
give non-overlapping rows the value -1 to avoid promoting columns to object. This will
change to NaN in a future version as general NaN becomes stable in pandas.
See also
--------
PyRanges.new_position : give joined PyRanges new coordinates
Examples
--------
>>> f1 = pr.from_dict({'Chromosome': ['chr1', 'chr1', 'chr1'], 'Start': [3, 8, 5],
... 'End': [6, 9, 7], 'Name': ['interval1', 'interval3', 'interval2']})
>>> f1
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | Name |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 3 | 6 | interval1 |
| chr1 | 8 | 9 | interval3 |
| chr1 | 5 | 7 | interval2 |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> f2 = pr.from_dict({'Chromosome': ['chr1', 'chr1'], 'Start': [1, 6],
... 'End': [2, 7], 'Name': ['a', 'b']})
>>> f2
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | Name |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 1 | 2 | a |
| chr1 | 6 | 7 | b |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> f1.join(f2)
+--------------+-----------+-----------+------------+-----------+-----------+------------+
| Chromosome | Start | End | Name | Start_b | End_b | Name_b |
| (category) | (int64) | (int64) | (object) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------+-----------+-----------+------------|
| chr1 | 5 | 7 | interval2 | 6 | 7 | b |
+--------------+-----------+-----------+------------+-----------+-----------+------------+
Unstranded PyRanges object has 1 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> f1.join(f2, how="right")
+--------------+-----------+-----------+------------+-----------+-----------+------------+
| Chromosome | Start | End | Name | Start_b | End_b | Name_b |
| (category) | (int64) | (int64) | (object) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------+-----------+-----------+------------|
| chr1 | 5 | 7 | interval2 | 6 | 7 | b |
| chr1 | -1 | -1 | -1 | 1 | 2 | a |
+--------------+-----------+-----------+------------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
With slack 1, bookended features are joined (see row 1):
>>> f1.join(f2, slack=1)
+--------------+-----------+-----------+------------+-----------+-----------+------------+
| Chromosome | Start | End | Name | Start_b | End_b | Name_b |
| (category) | (int64) | (int64) | (object) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------+-----------+-----------+------------|
| chr1 | 3 | 6 | interval1 | 6 | 7 | b |
| chr1 | 5 | 7 | interval2 | 6 | 7 | b |
+--------------+-----------+-----------+------------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> f1.join(f2, how="right", preserve_order=True)
+--------------+-----------+-----------+------------+-----------+-----------+------------+
| Chromosome | Start | End | Name | Start_b | End_b | Name_b |
| (category) | (int64) | (int64) | (object) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------+-----------+-----------+------------|
| chr1 | -1 | -1 | -1 | 1 | 2 | a |
| chr1 | 5 | 7 | interval2 | 6 | 7 | b |
+--------------+-----------+-----------+------------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
|
join
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def k_nearest(
self,
other,
k=1,
ties=None,
strandedness=None,
overlap=True,
how=None,
suffix="_b",
nb_cpu=1,
apply_strand_suffix=None,
):
"""Find k nearest intervals.
Parameters
----------
other : PyRanges
PyRanges to find nearest interval in.
k : int or list/array/Series of int
Number of closest to return. If iterable, must be same length as PyRanges.
ties : {None, "first", "last", "different"}, default None
How to resolve ties, i.e. closest intervals with equal distance. None means that the k nearest intervals are kept.
"first" means that the first tie is kept, "last" meanst that the last is kept.
"different" means that all nearest intervals with the k unique nearest distances are kept.
strandedness : {None, "same", "opposite", False}, default None, i.e. auto
Whether to compare PyRanges on the same strand, the opposite or ignore strand
information. The default, None, means use "same" if both PyRanges are stranded,
otherwise ignore the strand information.
overlap : bool, default True
Whether to include overlaps.
how : {None, "upstream", "downstream"}, default None, i.e. both directions
Whether to only look for nearest in one direction. Always with respect to the PyRanges
it is called on.
suffix : str, default "_b"
Suffix to give columns with shared name in other.
apply_strand_suffix : bool, default None
If first pyranges is unstranded, but the second is not, the first will be given a strand column.
apply_strand_suffix makes the added strand column a regular data column instead by adding a suffix.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
PyRanges
A PyRanges with columns of nearest interval horizontally appended.
Notes
-----
nearest also exists, and is more performant.
See also
--------
PyRanges.new_position : give joined PyRanges new coordinates
PyRanges.nearest : find nearest intervals
Examples
--------
>>> f1 = pr.from_dict({'Chromosome': ['chr1', 'chr1', 'chr1'], 'Start': [3, 8, 5],
... 'End': [6, 9, 7], 'Strand': ['+', '+', '-']})
>>> f1
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 3 | 6 | + |
| chr1 | 8 | 9 | + |
| chr1 | 5 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f2 = pr.from_dict({'Chromosome': ['chr1', 'chr1'], 'Start': [1, 6],
... 'End': [2, 7], 'Strand': ['+', '-']})
>>> f2
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 1 | 2 | + |
| chr1 | 6 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f1.k_nearest(f2, k=2)
+--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------+
| Chromosome | Start | End | Strand | Start_b | End_b | Strand_b | Distance |
| (category) | (int64) | (int64) | (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------|
| chr1 | 3 | 6 | + | 6 | 7 | - | 1 |
| chr1 | 3 | 6 | + | 1 | 2 | + | -2 |
| chr1 | 8 | 9 | + | 6 | 7 | - | -2 |
| chr1 | 8 | 9 | + | 1 | 2 | + | -7 |
| chr1 | 5 | 7 | - | 6 | 7 | - | 0 |
| chr1 | 5 | 7 | - | 1 | 2 | + | 4 |
+--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------+
Stranded PyRanges object has 6 rows and 8 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f1.k_nearest(f2, how="upstream", k=2)
+--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------+
| Chromosome | Start | End | Strand | Start_b | End_b | Strand_b | Distance |
| (category) | (int64) | (int64) | (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------|
| chr1 | 3 | 6 | + | 1 | 2 | + | -2 |
| chr1 | 8 | 9 | + | 6 | 7 | - | -2 |
| chr1 | 8 | 9 | + | 1 | 2 | + | -7 |
| chr1 | 5 | 7 | - | 6 | 7 | - | 0 |
+--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------+
Stranded PyRanges object has 4 rows and 8 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f1.k_nearest(f2, k=[1, 2, 1])
+--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------+
| Chromosome | Start | End | Strand | Start_b | End_b | Strand_b | Distance |
| (category) | (int64) | (int64) | (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------|
| chr1 | 3 | 6 | + | 6 | 7 | - | 1 |
| chr1 | 8 | 9 | + | 6 | 7 | - | -2 |
| chr1 | 8 | 9 | + | 1 | 2 | + | -7 |
| chr1 | 5 | 7 | - | 6 | 7 | - | 0 |
+--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------+
Stranded PyRanges object has 4 rows and 8 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> d1 = {"Chromosome": [1], "Start": [5], "End": [6]}
>>> d2 = {"Chromosome": 1, "Start": [1] * 2 + [5] * 2 + [9] * 2,
... "End": [3] * 2 + [7] * 2 + [11] * 2, "ID": range(6)}
>>> gr, gr2 = pr.from_dict(d1), pr.from_dict(d2)
>>> gr
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| 1 | 5 | 6 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 1 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr2
+--------------+-----------+-----------+-----------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------|
| 1 | 1 | 3 | 0 |
| 1 | 1 | 3 | 1 |
| 1 | 5 | 7 | 2 |
| 1 | 5 | 7 | 3 |
| 1 | 9 | 11 | 4 |
| 1 | 9 | 11 | 5 |
+--------------+-----------+-----------+-----------+
Unstranded PyRanges object has 6 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.k_nearest(gr2, k=2)
+--------------+-----------+-----------+-----------+-----------+-----------+------------+
| Chromosome | Start | End | Start_b | End_b | ID | Distance |
| (category) | (int64) | (int64) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------+-----------+------------|
| 1 | 5 | 6 | 5 | 7 | 2 | 0 |
| 1 | 5 | 6 | 5 | 7 | 3 | 0 |
+--------------+-----------+-----------+-----------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.k_nearest(gr2, k=2, ties="different")
+--------------+-----------+-----------+-----------+-----------+-----------+------------+
| Chromosome | Start | End | Start_b | End_b | ID | Distance |
| (category) | (int64) | (int64) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------+-----------+------------|
| 1 | 5 | 6 | 5 | 7 | 2 | 0 |
| 1 | 5 | 6 | 5 | 7 | 3 | 0 |
| 1 | 5 | 6 | 1 | 3 | 1 | -3 |
| 1 | 5 | 6 | 1 | 3 | 0 | -3 |
+--------------+-----------+-----------+-----------+-----------+-----------+------------+
Unstranded PyRanges object has 4 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.k_nearest(gr2, k=3, ties="first")
+--------------+-----------+-----------+-----------+-----------+-----------+------------+
| Chromosome | Start | End | Start_b | End_b | ID | Distance |
| (category) | (int64) | (int64) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------+-----------+------------|
| 1 | 5 | 6 | 5 | 7 | 2 | 0 |
| 1 | 5 | 6 | 1 | 3 | 1 | -3 |
| 1 | 5 | 6 | 9 | 11 | 4 | 4 |
+--------------+-----------+-----------+-----------+-----------+-----------+------------+
Unstranded PyRanges object has 3 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.k_nearest(gr2, k=1, overlap=False)
+--------------+-----------+-----------+-----------+-----------+-----------+------------+
| Chromosome | Start | End | Start_b | End_b | ID | Distance |
| (category) | (int64) | (int64) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------+-----------+------------|
| 1 | 5 | 6 | 1 | 3 | 1 | -3 |
+--------------+-----------+-----------+-----------+-----------+-----------+------------+
Unstranded PyRanges object has 1 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
"""
from sorted_nearest import get_all_ties, get_different_ties # type: ignore
from pyranges.methods.k_nearest import _nearest # type: ignore
kwargs = {
"strandedness": strandedness,
"how": how,
"overlap": overlap,
"nb_cpu": nb_cpu,
"k": k,
"ties": ties,
}
kwargs = fill_kwargs(kwargs)
kwargs["stranded"] = self.stranded and other.stranded
overlap = kwargs.get("overlap", True)
ties = kwargs.get("ties", False)
self = self.copy()
if isinstance(k, pd.Series):
k = k.values
# how many to nearest to find; might be different for each
self.__k__ = k
# give each their own unique ID
self.__IX__ = np.arange(len(self))
dfs = pyrange_apply(_nearest, self, other, **kwargs)
nearest = PyRanges(dfs)
if not overlap:
result = nearest
else:
from collections import defaultdict
overlap_how = defaultdict(lambda: None, {"first": "first", "last": "last"})[kwargs.get("ties")]
overlaps = self.join(
other,
strandedness=strandedness,
how=overlap_how,
nb_cpu=nb_cpu,
apply_strand_suffix=apply_strand_suffix,
)
overlaps.Distance = 0
result = pr.concat([overlaps, nearest])
if not len(result):
return pr.PyRanges()
new_result = {}
if ties in ["first", "last"]:
for c, df in result:
df = df.sort_values(["__IX__", "Distance"])
grpby = df.groupby("__k__", sort=False, observed=False)
dfs = []
for k, kdf in grpby:
grpby2 = kdf.groupby("__IX__", sort=False, observed=False)
_df = grpby2.head(k)
dfs.append(_df)
if dfs:
new_result[c] = pd.concat(dfs)
elif ties == "different" or not ties:
for c, df in result:
if df.empty:
continue
dfs = []
df = df.sort_values(["__IX__", "Distance"])
grpby = df.groupby("__k__", sort=False, observed=False)
for k, kdf in grpby:
if ties:
lx = get_different_ties(
kdf.index.values,
kdf.__IX__.values,
kdf.Distance.astype(np.int64).values,
k,
)
_df = kdf.reindex(lx)
else:
lx = get_all_ties(
kdf.index.values,
kdf.__IX__.values,
kdf.Distance.astype(np.int64).values,
k,
)
_df = kdf.reindex(lx)
_df = _df.groupby("__IX__", observed=False).head(k)
dfs.append(_df)
if dfs:
new_result[c] = pd.concat(dfs)
result = pr.PyRanges(new_result)
if not result.__IX__.is_monotonic_increasing:
result = result.sort("__IX__")
result = result.drop(like="__IX__|__k__")
self = self.drop(like="__k__|__IX__")
def prev_to_neg(df, **kwargs):
strand = df.Strand.iloc[0] if "Strand" in df else "+"
suffix = kwargs["suffix"]
bools = df["End" + suffix] < df.Start
if not strand == "+":
bools = ~bools
df.loc[bools, "Distance"] = -df.loc[bools, "Distance"]
return df
result = result.apply(prev_to_neg, suffix=kwargs["suffix"])
if not self.stranded and other.stranded:
if apply_strand_suffix is None:
import sys
print(
"join: Strand data from other will be added as strand data to self.\nIf this is undesired use the flag apply_strand_suffix=False.\nTo turn off the warning set apply_strand_suffix to True or False.",
file=sys.stderr,
)
elif apply_strand_suffix:
result.columns = result.columns.str.replace("Strand", "Strand" + kwargs["suffix"])
return result
|
Find k nearest intervals.
Parameters
----------
other : PyRanges
PyRanges to find nearest interval in.
k : int or list/array/Series of int
Number of closest to return. If iterable, must be same length as PyRanges.
ties : {None, "first", "last", "different"}, default None
How to resolve ties, i.e. closest intervals with equal distance. None means that the k nearest intervals are kept.
"first" means that the first tie is kept, "last" meanst that the last is kept.
"different" means that all nearest intervals with the k unique nearest distances are kept.
strandedness : {None, "same", "opposite", False}, default None, i.e. auto
Whether to compare PyRanges on the same strand, the opposite or ignore strand
information. The default, None, means use "same" if both PyRanges are stranded,
otherwise ignore the strand information.
overlap : bool, default True
Whether to include overlaps.
how : {None, "upstream", "downstream"}, default None, i.e. both directions
Whether to only look for nearest in one direction. Always with respect to the PyRanges
it is called on.
suffix : str, default "_b"
Suffix to give columns with shared name in other.
apply_strand_suffix : bool, default None
If first pyranges is unstranded, but the second is not, the first will be given a strand column.
apply_strand_suffix makes the added strand column a regular data column instead by adding a suffix.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
PyRanges
A PyRanges with columns of nearest interval horizontally appended.
Notes
-----
nearest also exists, and is more performant.
See also
--------
PyRanges.new_position : give joined PyRanges new coordinates
PyRanges.nearest : find nearest intervals
Examples
--------
>>> f1 = pr.from_dict({'Chromosome': ['chr1', 'chr1', 'chr1'], 'Start': [3, 8, 5],
... 'End': [6, 9, 7], 'Strand': ['+', '+', '-']})
>>> f1
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 3 | 6 | + |
| chr1 | 8 | 9 | + |
| chr1 | 5 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f2 = pr.from_dict({'Chromosome': ['chr1', 'chr1'], 'Start': [1, 6],
... 'End': [2, 7], 'Strand': ['+', '-']})
>>> f2
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 1 | 2 | + |
| chr1 | 6 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f1.k_nearest(f2, k=2)
+--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------+
| Chromosome | Start | End | Strand | Start_b | End_b | Strand_b | Distance |
| (category) | (int64) | (int64) | (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------|
| chr1 | 3 | 6 | + | 6 | 7 | - | 1 |
| chr1 | 3 | 6 | + | 1 | 2 | + | -2 |
| chr1 | 8 | 9 | + | 6 | 7 | - | -2 |
| chr1 | 8 | 9 | + | 1 | 2 | + | -7 |
| chr1 | 5 | 7 | - | 6 | 7 | - | 0 |
| chr1 | 5 | 7 | - | 1 | 2 | + | 4 |
+--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------+
Stranded PyRanges object has 6 rows and 8 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f1.k_nearest(f2, how="upstream", k=2)
+--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------+
| Chromosome | Start | End | Strand | Start_b | End_b | Strand_b | Distance |
| (category) | (int64) | (int64) | (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------|
| chr1 | 3 | 6 | + | 1 | 2 | + | -2 |
| chr1 | 8 | 9 | + | 6 | 7 | - | -2 |
| chr1 | 8 | 9 | + | 1 | 2 | + | -7 |
| chr1 | 5 | 7 | - | 6 | 7 | - | 0 |
+--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------+
Stranded PyRanges object has 4 rows and 8 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f1.k_nearest(f2, k=[1, 2, 1])
+--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------+
| Chromosome | Start | End | Strand | Start_b | End_b | Strand_b | Distance |
| (category) | (int64) | (int64) | (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------|
| chr1 | 3 | 6 | + | 6 | 7 | - | 1 |
| chr1 | 8 | 9 | + | 6 | 7 | - | -2 |
| chr1 | 8 | 9 | + | 1 | 2 | + | -7 |
| chr1 | 5 | 7 | - | 6 | 7 | - | 0 |
+--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------+
Stranded PyRanges object has 4 rows and 8 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> d1 = {"Chromosome": [1], "Start": [5], "End": [6]}
>>> d2 = {"Chromosome": 1, "Start": [1] * 2 + [5] * 2 + [9] * 2,
... "End": [3] * 2 + [7] * 2 + [11] * 2, "ID": range(6)}
>>> gr, gr2 = pr.from_dict(d1), pr.from_dict(d2)
>>> gr
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| 1 | 5 | 6 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 1 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr2
+--------------+-----------+-----------+-----------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------|
| 1 | 1 | 3 | 0 |
| 1 | 1 | 3 | 1 |
| 1 | 5 | 7 | 2 |
| 1 | 5 | 7 | 3 |
| 1 | 9 | 11 | 4 |
| 1 | 9 | 11 | 5 |
+--------------+-----------+-----------+-----------+
Unstranded PyRanges object has 6 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.k_nearest(gr2, k=2)
+--------------+-----------+-----------+-----------+-----------+-----------+------------+
| Chromosome | Start | End | Start_b | End_b | ID | Distance |
| (category) | (int64) | (int64) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------+-----------+------------|
| 1 | 5 | 6 | 5 | 7 | 2 | 0 |
| 1 | 5 | 6 | 5 | 7 | 3 | 0 |
+--------------+-----------+-----------+-----------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.k_nearest(gr2, k=2, ties="different")
+--------------+-----------+-----------+-----------+-----------+-----------+------------+
| Chromosome | Start | End | Start_b | End_b | ID | Distance |
| (category) | (int64) | (int64) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------+-----------+------------|
| 1 | 5 | 6 | 5 | 7 | 2 | 0 |
| 1 | 5 | 6 | 5 | 7 | 3 | 0 |
| 1 | 5 | 6 | 1 | 3 | 1 | -3 |
| 1 | 5 | 6 | 1 | 3 | 0 | -3 |
+--------------+-----------+-----------+-----------+-----------+-----------+------------+
Unstranded PyRanges object has 4 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.k_nearest(gr2, k=3, ties="first")
+--------------+-----------+-----------+-----------+-----------+-----------+------------+
| Chromosome | Start | End | Start_b | End_b | ID | Distance |
| (category) | (int64) | (int64) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------+-----------+------------|
| 1 | 5 | 6 | 5 | 7 | 2 | 0 |
| 1 | 5 | 6 | 1 | 3 | 1 | -3 |
| 1 | 5 | 6 | 9 | 11 | 4 | 4 |
+--------------+-----------+-----------+-----------+-----------+-----------+------------+
Unstranded PyRanges object has 3 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.k_nearest(gr2, k=1, overlap=False)
+--------------+-----------+-----------+-----------+-----------+-----------+------------+
| Chromosome | Start | End | Start_b | End_b | ID | Distance |
| (category) | (int64) | (int64) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------+-----------+------------|
| 1 | 5 | 6 | 1 | 3 | 1 | -3 |
+--------------+-----------+-----------+-----------+-----------+-----------+------------+
Unstranded PyRanges object has 1 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
|
k_nearest
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def lengths(self, as_dict=False):
"""Return the length of each interval.
Parameters
----------
as_dict : bool, default False
Whether to return lengths as Series or dict of Series per key.
Returns
-------
Series or dict of Series with the lengths of each interval.
See Also
--------
PyRanges.lengths : return the intervals lengths
Examples
--------
>>> gr = pr.data.f1()
>>> gr
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 3 | 6 | interval1 | 0 | + |
| chr1 | 8 | 9 | interval3 | 0 | + |
| chr1 | 5 | 7 | interval2 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 3 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.lengths()
0 3
1 1
2 2
dtype: int64
To find the length of the genome covered by the intervals, use merge first:
>>> gr.Length = gr.lengths()
>>> gr
+--------------+-----------+-----------+------------+-----------+--------------+-----------+
| Chromosome | Start | End | Name | Score | Strand | Length |
| (category) | (int64) | (int64) | (object) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+------------+-----------+--------------+-----------|
| chr1 | 3 | 6 | interval1 | 0 | + | 3 |
| chr1 | 8 | 9 | interval3 | 0 | + | 1 |
| chr1 | 5 | 7 | interval2 | 0 | - | 2 |
+--------------+-----------+-----------+------------+-----------+--------------+-----------+
Stranded PyRanges object has 3 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
if as_dict:
if not len(self):
return {}
lengths = {}
for k, df in self.items():
lengths[k] = df.End - df.Start
return lengths
else:
_lengths = []
if not len(self):
return np.array(_lengths, dtype=int)
for _, df in self:
lengths = df.End - df.Start
_lengths.append(lengths)
return pd.concat(_lengths).reset_index(drop=True)
|
Return the length of each interval.
Parameters
----------
as_dict : bool, default False
Whether to return lengths as Series or dict of Series per key.
Returns
-------
Series or dict of Series with the lengths of each interval.
See Also
--------
PyRanges.lengths : return the intervals lengths
Examples
--------
>>> gr = pr.data.f1()
>>> gr
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 3 | 6 | interval1 | 0 | + |
| chr1 | 8 | 9 | interval3 | 0 | + |
| chr1 | 5 | 7 | interval2 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 3 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.lengths()
0 3
1 1
2 2
dtype: int64
To find the length of the genome covered by the intervals, use merge first:
>>> gr.Length = gr.lengths()
>>> gr
+--------------+-----------+-----------+------------+-----------+--------------+-----------+
| Chromosome | Start | End | Name | Score | Strand | Length |
| (category) | (int64) | (int64) | (object) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+------------+-----------+--------------+-----------|
| chr1 | 3 | 6 | interval1 | 0 | + | 3 |
| chr1 | 8 | 9 | interval3 | 0 | + | 1 |
| chr1 | 5 | 7 | interval2 | 0 | - | 2 |
+--------------+-----------+-----------+------------+-----------+--------------+-----------+
Stranded PyRanges object has 3 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
lengths
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def max_disjoint(self, strand=None, slack=0, **kwargs):
"""Find the maximal disjoint set of intervals.
Parameters
----------
strand : bool, default None, i.e. auto
Find the max disjoint set separately for each strand.
slack : int, default 0
Consider intervals within a distance of slack to be overlapping.
Returns
-------
PyRanges
PyRanges with maximal disjoint set of intervals.
Examples
--------
>>> gr = pr.data.f1()
>>> gr
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 3 | 6 | interval1 | 0 | + |
| chr1 | 8 | 9 | interval3 | 0 | + |
| chr1 | 5 | 7 | interval2 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 3 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.max_disjoint(strand=False)
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 3 | 6 | interval1 | 0 | + |
| chr1 | 8 | 9 | interval3 | 0 | + |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 2 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
if strand is None:
strand = self.stranded
kwargs = {"strand": strand, "slack": slack}
kwargs = fill_kwargs(kwargs)
from pyranges.methods.max_disjoint import _max_disjoint
df = pyrange_apply_single(_max_disjoint, self, **kwargs)
return pr.PyRanges(df)
|
Find the maximal disjoint set of intervals.
Parameters
----------
strand : bool, default None, i.e. auto
Find the max disjoint set separately for each strand.
slack : int, default 0
Consider intervals within a distance of slack to be overlapping.
Returns
-------
PyRanges
PyRanges with maximal disjoint set of intervals.
Examples
--------
>>> gr = pr.data.f1()
>>> gr
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 3 | 6 | interval1 | 0 | + |
| chr1 | 8 | 9 | interval3 | 0 | + |
| chr1 | 5 | 7 | interval2 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 3 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.max_disjoint(strand=False)
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 3 | 6 | interval1 | 0 | + |
| chr1 | 8 | 9 | interval3 | 0 | + |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 2 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
max_disjoint
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def merge(self, strand=None, count=False, count_col="Count", by=None, slack=0):
"""Merge overlapping intervals into one.
Parameters
----------
strand : bool, default None, i.e. auto
Only merge intervals on same strand.
count : bool, default False
Count intervals in each superinterval.
count_col : str, default "Count"
Name of column with counts.
by : str or list of str, default None
Only merge intervals with equal values in these columns.
slack : int, default 0
Allow this many nucleotides between each interval to merge.
Returns
-------
PyRanges
PyRanges with superintervals.
Notes
-----
To avoid losing metadata, use cluster instead. If you want to perform a reduction function
on the metadata, use pandas groupby.
See Also
--------
PyRanges.cluster : annotate overlapping intervals with common ID
Examples
--------
>>> gr = pr.data.ensembl_gtf()[["Feature", "gene_name"]]
>>> gr
+--------------+--------------+-----------+-----------+--------------+-------------+
| Chromosome | Feature | Start | End | Strand | gene_name |
| (category) | (category) | (int64) | (int64) | (category) | (object) |
|--------------+--------------+-----------+-----------+--------------+-------------|
| 1 | gene | 11868 | 14409 | + | DDX11L1 |
| 1 | transcript | 11868 | 14409 | + | DDX11L1 |
| 1 | exon | 11868 | 12227 | + | DDX11L1 |
| 1 | exon | 12612 | 12721 | + | DDX11L1 |
| ... | ... | ... | ... | ... | ... |
| 1 | gene | 1173055 | 1179555 | - | TTLL10-AS1 |
| 1 | transcript | 1173055 | 1179555 | - | TTLL10-AS1 |
| 1 | exon | 1179364 | 1179555 | - | TTLL10-AS1 |
| 1 | exon | 1173055 | 1176396 | - | TTLL10-AS1 |
+--------------+--------------+-----------+-----------+--------------+-------------+
Stranded PyRanges object has 2,446 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.merge(count=True, count_col="Count")
+--------------+-----------+-----------+--------------+-----------+
| Chromosome | Start | End | Strand | Count |
| (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------|
| 1 | 11868 | 14409 | + | 12 |
| 1 | 29553 | 31109 | + | 11 |
| 1 | 52472 | 53312 | + | 3 |
| 1 | 57597 | 64116 | + | 7 |
| ... | ... | ... | ... | ... |
| 1 | 1062207 | 1063288 | - | 4 |
| 1 | 1070966 | 1074306 | - | 10 |
| 1 | 1081817 | 1116361 | - | 319 |
| 1 | 1173055 | 1179555 | - | 4 |
+--------------+-----------+-----------+--------------+-----------+
Stranded PyRanges object has 62 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.merge(by="Feature", count=True)
+--------------+-----------+-----------+--------------+--------------+-----------+
| Chromosome | Start | End | Strand | Feature | Count |
| (category) | (int64) | (int64) | (category) | (category) | (int64) |
|--------------+-----------+-----------+--------------+--------------+-----------|
| 1 | 65564 | 65573 | + | CDS | 1 |
| 1 | 69036 | 70005 | + | CDS | 2 |
| 1 | 924431 | 924948 | + | CDS | 1 |
| 1 | 925921 | 926013 | + | CDS | 11 |
| ... | ... | ... | ... | ... | ... |
| 1 | 1062207 | 1063288 | - | transcript | 1 |
| 1 | 1070966 | 1074306 | - | transcript | 1 |
| 1 | 1081817 | 1116361 | - | transcript | 19 |
| 1 | 1173055 | 1179555 | - | transcript | 1 |
+--------------+-----------+-----------+--------------+--------------+-----------+
Stranded PyRanges object has 748 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.merge(by=["Feature", "gene_name"], count=True)
+--------------+-----------+-----------+--------------+--------------+-------------+-----------+
| Chromosome | Start | End | Strand | Feature | gene_name | Count |
| (category) | (int64) | (int64) | (category) | (category) | (object) | (int64) |
|--------------+-----------+-----------+--------------+--------------+-------------+-----------|
| 1 | 1020172 | 1020373 | + | CDS | AGRN | 1 |
| 1 | 1022200 | 1022462 | + | CDS | AGRN | 2 |
| 1 | 1034555 | 1034703 | + | CDS | AGRN | 2 |
| 1 | 1035276 | 1035324 | + | CDS | AGRN | 4 |
| ... | ... | ... | ... | ... | ... | ... |
| 1 | 347981 | 348366 | - | transcript | RPL23AP24 | 1 |
| 1 | 1173055 | 1179555 | - | transcript | TTLL10-AS1 | 1 |
| 1 | 14403 | 29570 | - | transcript | WASH7P | 1 |
| 1 | 185216 | 195411 | - | transcript | WASH9P | 1 |
+--------------+-----------+-----------+--------------+--------------+-------------+-----------+
Stranded PyRanges object has 807 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
if strand is None:
strand = self.stranded
kwargs = {
"strand": strand,
"count": count,
"by": by,
"count_col": count_col,
"slack": slack,
}
if not kwargs["by"]:
kwargs["sparse"] = {"self": True}
from pyranges.methods.merge import _merge
df = pyrange_apply_single(_merge, self, **kwargs)
else:
kwargs["sparse"] = {"self": False}
from pyranges.methods.merge import _merge_by
df = pyrange_apply_single(_merge_by, self, **kwargs)
return PyRanges(df)
|
Merge overlapping intervals into one.
Parameters
----------
strand : bool, default None, i.e. auto
Only merge intervals on same strand.
count : bool, default False
Count intervals in each superinterval.
count_col : str, default "Count"
Name of column with counts.
by : str or list of str, default None
Only merge intervals with equal values in these columns.
slack : int, default 0
Allow this many nucleotides between each interval to merge.
Returns
-------
PyRanges
PyRanges with superintervals.
Notes
-----
To avoid losing metadata, use cluster instead. If you want to perform a reduction function
on the metadata, use pandas groupby.
See Also
--------
PyRanges.cluster : annotate overlapping intervals with common ID
Examples
--------
>>> gr = pr.data.ensembl_gtf()[["Feature", "gene_name"]]
>>> gr
+--------------+--------------+-----------+-----------+--------------+-------------+
| Chromosome | Feature | Start | End | Strand | gene_name |
| (category) | (category) | (int64) | (int64) | (category) | (object) |
|--------------+--------------+-----------+-----------+--------------+-------------|
| 1 | gene | 11868 | 14409 | + | DDX11L1 |
| 1 | transcript | 11868 | 14409 | + | DDX11L1 |
| 1 | exon | 11868 | 12227 | + | DDX11L1 |
| 1 | exon | 12612 | 12721 | + | DDX11L1 |
| ... | ... | ... | ... | ... | ... |
| 1 | gene | 1173055 | 1179555 | - | TTLL10-AS1 |
| 1 | transcript | 1173055 | 1179555 | - | TTLL10-AS1 |
| 1 | exon | 1179364 | 1179555 | - | TTLL10-AS1 |
| 1 | exon | 1173055 | 1176396 | - | TTLL10-AS1 |
+--------------+--------------+-----------+-----------+--------------+-------------+
Stranded PyRanges object has 2,446 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.merge(count=True, count_col="Count")
+--------------+-----------+-----------+--------------+-----------+
| Chromosome | Start | End | Strand | Count |
| (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------|
| 1 | 11868 | 14409 | + | 12 |
| 1 | 29553 | 31109 | + | 11 |
| 1 | 52472 | 53312 | + | 3 |
| 1 | 57597 | 64116 | + | 7 |
| ... | ... | ... | ... | ... |
| 1 | 1062207 | 1063288 | - | 4 |
| 1 | 1070966 | 1074306 | - | 10 |
| 1 | 1081817 | 1116361 | - | 319 |
| 1 | 1173055 | 1179555 | - | 4 |
+--------------+-----------+-----------+--------------+-----------+
Stranded PyRanges object has 62 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.merge(by="Feature", count=True)
+--------------+-----------+-----------+--------------+--------------+-----------+
| Chromosome | Start | End | Strand | Feature | Count |
| (category) | (int64) | (int64) | (category) | (category) | (int64) |
|--------------+-----------+-----------+--------------+--------------+-----------|
| 1 | 65564 | 65573 | + | CDS | 1 |
| 1 | 69036 | 70005 | + | CDS | 2 |
| 1 | 924431 | 924948 | + | CDS | 1 |
| 1 | 925921 | 926013 | + | CDS | 11 |
| ... | ... | ... | ... | ... | ... |
| 1 | 1062207 | 1063288 | - | transcript | 1 |
| 1 | 1070966 | 1074306 | - | transcript | 1 |
| 1 | 1081817 | 1116361 | - | transcript | 19 |
| 1 | 1173055 | 1179555 | - | transcript | 1 |
+--------------+-----------+-----------+--------------+--------------+-----------+
Stranded PyRanges object has 748 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.merge(by=["Feature", "gene_name"], count=True)
+--------------+-----------+-----------+--------------+--------------+-------------+-----------+
| Chromosome | Start | End | Strand | Feature | gene_name | Count |
| (category) | (int64) | (int64) | (category) | (category) | (object) | (int64) |
|--------------+-----------+-----------+--------------+--------------+-------------+-----------|
| 1 | 1020172 | 1020373 | + | CDS | AGRN | 1 |
| 1 | 1022200 | 1022462 | + | CDS | AGRN | 2 |
| 1 | 1034555 | 1034703 | + | CDS | AGRN | 2 |
| 1 | 1035276 | 1035324 | + | CDS | AGRN | 4 |
| ... | ... | ... | ... | ... | ... | ... |
| 1 | 347981 | 348366 | - | transcript | RPL23AP24 | 1 |
| 1 | 1173055 | 1179555 | - | transcript | TTLL10-AS1 | 1 |
| 1 | 14403 | 29570 | - | transcript | WASH7P | 1 |
| 1 | 185216 | 195411 | - | transcript | WASH9P | 1 |
+--------------+-----------+-----------+--------------+--------------+-------------+-----------+
Stranded PyRanges object has 807 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
merge
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def nearest(
self,
other,
strandedness=None,
overlap=True,
how=None,
suffix="_b",
nb_cpu=1,
apply_strand_suffix=None,
):
"""Find closest interval.
Parameters
----------
other : PyRanges
PyRanges to find nearest interval in.
strandedness : {None, "same", "opposite", False}, default None, i.e. auto
Whether to compare PyRanges on the same strand, the opposite or ignore strand
information. The default, None, means use "same" if both PyRanges are strande,
otherwise ignore the strand information.
overlap : bool, default True
Whether to include overlaps.
how : {None, "upstream", "downstream"}, default None, i.e. both directions
Whether to only look for nearest in one direction. Always with respect to the PyRanges
it is called on.
suffix : str, default "_b"
Suffix to give columns with shared name in other.
apply_strand_suffix : bool, default None
If first pyranges is unstranded, but the second is not, the first will be given the strand column of the second.
apply_strand_suffix makes the added strand column a regular data column instead by adding a suffix.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
PyRanges
A PyRanges with columns representing nearest interval horizontally appended.
Notes
-----
A k_nearest also exists, but is less performant.
See also
--------
PyRanges.new_position : give joined PyRanges new coordinates
PyRanges.k_nearest : find k nearest intervals
Examples
--------
>>> f1 = pr.from_dict({'Chromosome': ['chr1', 'chr1', 'chr1'], 'Start': [3, 8, 5],
... 'End': [6, 9, 7], 'Strand': ['+', '+', '-']})
>>> f1
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 3 | 6 | + |
| chr1 | 8 | 9 | + |
| chr1 | 5 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f2 = pr.from_dict({'Chromosome': ['chr1', 'chr1'], 'Start': [1, 6],
... 'End': [2, 7], 'Strand': ['+', '-']})
>>> f2
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 1 | 2 | + |
| chr1 | 6 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f1.nearest(f2)
+--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------+
| Chromosome | Start | End | Strand | Start_b | End_b | Strand_b | Distance |
| (category) | (int64) | (int64) | (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------|
| chr1 | 3 | 6 | + | 6 | 7 | - | 1 |
| chr1 | 8 | 9 | + | 6 | 7 | - | 2 |
| chr1 | 5 | 7 | - | 6 | 7 | - | 0 |
+--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------+
Stranded PyRanges object has 3 rows and 8 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f1.nearest(f2, how="upstream")
+--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------+
| Chromosome | Start | End | Strand | Start_b | End_b | Strand_b | Distance |
| (category) | (int64) | (int64) | (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------|
| chr1 | 3 | 6 | + | 1 | 2 | + | 2 |
| chr1 | 8 | 9 | + | 6 | 7 | - | 2 |
| chr1 | 5 | 7 | - | 6 | 7 | - | 0 |
+--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------+
Stranded PyRanges object has 3 rows and 8 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
from pyranges.methods.nearest import _nearest
kwargs = {
"strandedness": strandedness,
"how": how,
"overlap": overlap,
"nb_cpu": nb_cpu,
"suffix": suffix,
"apply_strand_suffix": apply_strand_suffix,
}
kwargs = fill_kwargs(kwargs)
if kwargs.get("how") in "upstream downstream".split():
assert other.stranded, "If doing upstream or downstream nearest, other pyranges must be stranded"
dfs = pyrange_apply(_nearest, self, other, **kwargs)
gr = PyRanges(dfs)
if not self.stranded and other.stranded:
if apply_strand_suffix is None:
import sys
print(
"join: Strand data from other will be added as strand data to self.\nIf this is undesired use the flag apply_strand_suffix=False.\nTo turn off the warning set apply_strand_suffix to True or False.",
file=sys.stderr,
)
elif apply_strand_suffix:
gr.columns = gr.columns.str.replace("Strand", "Strand" + kwargs["suffix"])
return gr
|
Find closest interval.
Parameters
----------
other : PyRanges
PyRanges to find nearest interval in.
strandedness : {None, "same", "opposite", False}, default None, i.e. auto
Whether to compare PyRanges on the same strand, the opposite or ignore strand
information. The default, None, means use "same" if both PyRanges are strande,
otherwise ignore the strand information.
overlap : bool, default True
Whether to include overlaps.
how : {None, "upstream", "downstream"}, default None, i.e. both directions
Whether to only look for nearest in one direction. Always with respect to the PyRanges
it is called on.
suffix : str, default "_b"
Suffix to give columns with shared name in other.
apply_strand_suffix : bool, default None
If first pyranges is unstranded, but the second is not, the first will be given the strand column of the second.
apply_strand_suffix makes the added strand column a regular data column instead by adding a suffix.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
PyRanges
A PyRanges with columns representing nearest interval horizontally appended.
Notes
-----
A k_nearest also exists, but is less performant.
See also
--------
PyRanges.new_position : give joined PyRanges new coordinates
PyRanges.k_nearest : find k nearest intervals
Examples
--------
>>> f1 = pr.from_dict({'Chromosome': ['chr1', 'chr1', 'chr1'], 'Start': [3, 8, 5],
... 'End': [6, 9, 7], 'Strand': ['+', '+', '-']})
>>> f1
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 3 | 6 | + |
| chr1 | 8 | 9 | + |
| chr1 | 5 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f2 = pr.from_dict({'Chromosome': ['chr1', 'chr1'], 'Start': [1, 6],
... 'End': [2, 7], 'Strand': ['+', '-']})
>>> f2
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 1 | 2 | + |
| chr1 | 6 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f1.nearest(f2)
+--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------+
| Chromosome | Start | End | Strand | Start_b | End_b | Strand_b | Distance |
| (category) | (int64) | (int64) | (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------|
| chr1 | 3 | 6 | + | 6 | 7 | - | 1 |
| chr1 | 8 | 9 | + | 6 | 7 | - | 2 |
| chr1 | 5 | 7 | - | 6 | 7 | - | 0 |
+--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------+
Stranded PyRanges object has 3 rows and 8 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> f1.nearest(f2, how="upstream")
+--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------+
| Chromosome | Start | End | Strand | Start_b | End_b | Strand_b | Distance |
| (category) | (int64) | (int64) | (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------|
| chr1 | 3 | 6 | + | 1 | 2 | + | 2 |
| chr1 | 8 | 9 | + | 6 | 7 | - | 2 |
| chr1 | 5 | 7 | - | 6 | 7 | - | 0 |
+--------------+-----------+-----------+--------------+-----------+-----------+--------------+------------+
Stranded PyRanges object has 3 rows and 8 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
nearest
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def new_position(self, new_pos, columns=None):
"""Give new position.
The operation join produces a PyRanges with two pairs of start coordinates and two pairs of
end coordinates. This operation uses these to give the PyRanges a new position.
Parameters
----------
new_pos : {"union", "intersection", "swap"}
Change of coordinates.
columns : tuple of str, default None, i.e. auto
The name of the coordinate columns. By default uses the two first columns containing
"Start" and the two first columns containing "End".
See Also
--------
PyRanges.join : combine two PyRanges horizontally with SQL-style joins.
Returns
-------
PyRanges
PyRanges with new coordinates.
Examples
--------
>>> gr = pr.from_dict({'Chromosome': ['chr1', 'chr1', 'chr1'],
... 'Start': [3, 8, 5], 'End': [6, 9, 7]})
>>> gr
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 3 | 6 |
| chr1 | 8 | 9 |
| chr1 | 5 | 7 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr2 = pr.from_dict({'Chromosome': ['chr1', 'chr1'], 'Start': [1, 6],
... 'End': [4, 7]})
>>> gr2
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 1 | 4 |
| chr1 | 6 | 7 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> j = gr.join(gr2)
>>> j
+--------------+-----------+-----------+-----------+-----------+
| Chromosome | Start | End | Start_b | End_b |
| (category) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------|
| chr1 | 3 | 6 | 1 | 4 |
| chr1 | 5 | 7 | 6 | 7 |
+--------------+-----------+-----------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> j.new_position("swap")
+--------------+-----------+-----------+-----------+-----------+
| Chromosome | Start | End | Start_b | End_b |
| (category) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------|
| chr1 | 1 | 4 | 3 | 6 |
| chr1 | 6 | 7 | 5 | 7 |
+--------------+-----------+-----------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> j.new_position("union").mp()
+--------------------+-----------+-----------+
| - Position - | Start_b | End_b |
| (Multiple types) | (int64) | (int64) |
|--------------------+-----------+-----------|
| chr1 1-6 | 1 | 4 |
| chr1 5-7 | 6 | 7 |
+--------------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> j.new_position("intersection").mp()
+--------------------+-----------+-----------+
| - Position - | Start_b | End_b |
| (Multiple types) | (int64) | (int64) |
|--------------------+-----------+-----------|
| chr1 1-4 | 1 | 4 |
| chr1 6-7 | 6 | 7 |
+--------------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> j2 = pr.from_dict({"Chromosome": [1], "Start": [3],
... "End": [4], "A": [1], "B": [3], "C": [2], "D": [5]})
>>> j2
+--------------+-----------+-----------+-----------+-----------+-----------+-----------+
| Chromosome | Start | End | A | B | C | D |
| (category) | (int64) | (int64) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------+-----------+-----------|
| 1 | 3 | 4 | 1 | 3 | 2 | 5 |
+--------------+-----------+-----------+-----------+-----------+-----------+-----------+
Unstranded PyRanges object has 1 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> j2.new_position("intersection", ("A", "B", "C", "D"))
+--------------+-----------+-----------+-----------+-----------+-----------+-----------+
| Chromosome | Start | End | A | B | C | D |
| (category) | (int64) | (int64) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------+-----------+-----------|
| 1 | 2 | 3 | 1 | 3 | 2 | 5 |
+--------------+-----------+-----------+-----------+-----------+-----------+-----------+
Unstranded PyRanges object has 1 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
"""
from pyranges.methods.new_position import _new_position
if self.empty:
return self
kwargs = {"strand": None}
kwargs["sparse"] = {"self": False}
kwargs["new_pos"] = new_pos
if columns is None:
start1, start2 = self.columns[self.columns.str.contains("Start")][:2]
end1, end2 = self.columns[self.columns.str.contains("End")][:2]
columns = (start1, end1, start2, end2)
kwargs["columns"] = columns
kwargs = fill_kwargs(kwargs)
dfs = pyrange_apply_single(_new_position, self, **kwargs)
return pr.PyRanges(dfs)
|
Give new position.
The operation join produces a PyRanges with two pairs of start coordinates and two pairs of
end coordinates. This operation uses these to give the PyRanges a new position.
Parameters
----------
new_pos : {"union", "intersection", "swap"}
Change of coordinates.
columns : tuple of str, default None, i.e. auto
The name of the coordinate columns. By default uses the two first columns containing
"Start" and the two first columns containing "End".
See Also
--------
PyRanges.join : combine two PyRanges horizontally with SQL-style joins.
Returns
-------
PyRanges
PyRanges with new coordinates.
Examples
--------
>>> gr = pr.from_dict({'Chromosome': ['chr1', 'chr1', 'chr1'],
... 'Start': [3, 8, 5], 'End': [6, 9, 7]})
>>> gr
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 3 | 6 |
| chr1 | 8 | 9 |
| chr1 | 5 | 7 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr2 = pr.from_dict({'Chromosome': ['chr1', 'chr1'], 'Start': [1, 6],
... 'End': [4, 7]})
>>> gr2
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 1 | 4 |
| chr1 | 6 | 7 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> j = gr.join(gr2)
>>> j
+--------------+-----------+-----------+-----------+-----------+
| Chromosome | Start | End | Start_b | End_b |
| (category) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------|
| chr1 | 3 | 6 | 1 | 4 |
| chr1 | 5 | 7 | 6 | 7 |
+--------------+-----------+-----------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> j.new_position("swap")
+--------------+-----------+-----------+-----------+-----------+
| Chromosome | Start | End | Start_b | End_b |
| (category) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------|
| chr1 | 1 | 4 | 3 | 6 |
| chr1 | 6 | 7 | 5 | 7 |
+--------------+-----------+-----------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> j.new_position("union").mp()
+--------------------+-----------+-----------+
| - Position - | Start_b | End_b |
| (Multiple types) | (int64) | (int64) |
|--------------------+-----------+-----------|
| chr1 1-6 | 1 | 4 |
| chr1 5-7 | 6 | 7 |
+--------------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> j.new_position("intersection").mp()
+--------------------+-----------+-----------+
| - Position - | Start_b | End_b |
| (Multiple types) | (int64) | (int64) |
|--------------------+-----------+-----------|
| chr1 1-4 | 1 | 4 |
| chr1 6-7 | 6 | 7 |
+--------------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> j2 = pr.from_dict({"Chromosome": [1], "Start": [3],
... "End": [4], "A": [1], "B": [3], "C": [2], "D": [5]})
>>> j2
+--------------+-----------+-----------+-----------+-----------+-----------+-----------+
| Chromosome | Start | End | A | B | C | D |
| (category) | (int64) | (int64) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------+-----------+-----------|
| 1 | 3 | 4 | 1 | 3 | 2 | 5 |
+--------------+-----------+-----------+-----------+-----------+-----------+-----------+
Unstranded PyRanges object has 1 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> j2.new_position("intersection", ("A", "B", "C", "D"))
+--------------+-----------+-----------+-----------+-----------+-----------+-----------+
| Chromosome | Start | End | A | B | C | D |
| (category) | (int64) | (int64) | (int64) | (int64) | (int64) | (int64) |
|--------------+-----------+-----------+-----------+-----------+-----------+-----------|
| 1 | 2 | 3 | 1 | 3 | 2 | 5 |
+--------------+-----------+-----------+-----------+-----------+-----------+-----------+
Unstranded PyRanges object has 1 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
|
new_position
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def overlap(self, other, strandedness=None, how="first", invert=False, nb_cpu=1):
"""Return overlapping intervals.
Returns the intervals in self which overlap with those in other.
Parameters
----------
other : PyRanges
PyRanges to find overlaps with.
strandedness : {None, "same", "opposite", False}, default None, i.e. auto
Whether to compare PyRanges on the same strand, the opposite or ignore strand
information. The default, None, means use "same" if both PyRanges are strande,
otherwise ignore the strand information.
how : {"first", "containment", False, None}, default "first"
What intervals to report. By default, reports every interval in self with overlap once.
"containment" reports all intervals where the overlapping is contained within it.
invert : bool, default False
Whether to return the intervals without overlaps.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
PyRanges
A PyRanges with overlapping intervals.
See also
--------
PyRanges.intersect : report overlapping subintervals
PyRanges.set_intersect : set-intersect PyRanges
Examples
--------
>>> gr = pr.from_dict({"Chromosome": ["chr1"] * 3, "Start": [1, 4, 10],
... "End": [3, 9, 11], "ID": ["a", "b", "c"]})
>>> gr
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 1 | 3 | a |
| chr1 | 4 | 9 | b |
| chr1 | 10 | 11 | c |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr2 = pr.from_dict({"Chromosome": ["chr1"] * 3, "Start": [2, 2, 9], "End": [3, 9, 10]})
>>> gr2
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 2 | 3 |
| chr1 | 2 | 9 |
| chr1 | 9 | 10 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.overlap(gr2)
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 1 | 3 | a |
| chr1 | 4 | 9 | b |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.overlap(gr2, how=None)
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 1 | 3 | a |
| chr1 | 1 | 3 | a |
| chr1 | 4 | 9 | b |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.overlap(gr2, how="containment")
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 4 | 9 | b |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 1 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.overlap(gr2, invert=True)
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 10 | 11 | c |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 1 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
"""
kwargs = {"strandedness": strandedness, "nb_cpu": nb_cpu}
kwargs["sparse"] = {"self": False, "other": True}
kwargs["how"] = how
kwargs["invert"] = invert
kwargs = fill_kwargs(kwargs)
if len(self) == 0:
return self
if invert:
self = self.copy()
self.__ix__ = np.arange(len(self))
dfs = pyrange_apply(_overlap, self, other, **kwargs)
result = pr.PyRanges(dfs)
if invert:
found_idxs = getattr(result, "__ix__", [])
result = self[~self.__ix__.isin(found_idxs)]
result = result.drop("__ix__")
return result
|
Return overlapping intervals.
Returns the intervals in self which overlap with those in other.
Parameters
----------
other : PyRanges
PyRanges to find overlaps with.
strandedness : {None, "same", "opposite", False}, default None, i.e. auto
Whether to compare PyRanges on the same strand, the opposite or ignore strand
information. The default, None, means use "same" if both PyRanges are strande,
otherwise ignore the strand information.
how : {"first", "containment", False, None}, default "first"
What intervals to report. By default, reports every interval in self with overlap once.
"containment" reports all intervals where the overlapping is contained within it.
invert : bool, default False
Whether to return the intervals without overlaps.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
PyRanges
A PyRanges with overlapping intervals.
See also
--------
PyRanges.intersect : report overlapping subintervals
PyRanges.set_intersect : set-intersect PyRanges
Examples
--------
>>> gr = pr.from_dict({"Chromosome": ["chr1"] * 3, "Start": [1, 4, 10],
... "End": [3, 9, 11], "ID": ["a", "b", "c"]})
>>> gr
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 1 | 3 | a |
| chr1 | 4 | 9 | b |
| chr1 | 10 | 11 | c |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr2 = pr.from_dict({"Chromosome": ["chr1"] * 3, "Start": [2, 2, 9], "End": [3, 9, 10]})
>>> gr2
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 2 | 3 |
| chr1 | 2 | 9 |
| chr1 | 9 | 10 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.overlap(gr2)
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 1 | 3 | a |
| chr1 | 4 | 9 | b |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.overlap(gr2, how=None)
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 1 | 3 | a |
| chr1 | 1 | 3 | a |
| chr1 | 4 | 9 | b |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.overlap(gr2, how="containment")
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 4 | 9 | b |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 1 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.overlap(gr2, invert=True)
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 10 | 11 | c |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 1 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
|
overlap
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def print(self, n=8, merge_position=False, sort=False, formatting=None, chain=False):
"""Print the PyRanges.
Parameters
----------
n : int, default 8
The number of rows to print.
merge_postion : bool, default False
Print location in same column to save screen space.
sort : bool or str, default False
Sort the PyRanges before printing. Will print chromosomsomes or strands interleaved on
sort columns.
formatting : dict, default None
Formatting options per column.
chain : False
Return the PyRanges. Useful to print intermediate results in call chains.
See Also
--------
PyRanges.pc : print chain
PyRanges.sp : sort print
PyRanges.mp : merge print
PyRanges.spc : sort print chain
PyRanges.mpc : merge print chain
PyRanges.msp : merge sort print
PyRanges.mspc : merge sort print chain
PyRanges.rp : raw print dictionary of DataFrames
Examples
--------
>>> d = {'Chromosome': ['chr1', 'chr1', 'chr1'], 'Start': [3, 8, 5000],
... 'End': [6, 9, 7000], 'Name': ['i1', 'i3', 'i2'],
... 'Score': [1.1, 2.3987, 5.9999995], 'Strand': ['+', '+', '-']}
>>> gr = pr.from_dict(d)
>>> gr
+--------------+-----------+-----------+------------+-------------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (float64) | (category) |
|--------------+-----------+-----------+------------+-------------+--------------|
| chr1 | 3 | 6 | i1 | 1.1 | + |
| chr1 | 8 | 9 | i3 | 2.3987 | + |
| chr1 | 5000 | 7000 | i2 | 6 | - |
+--------------+-----------+-----------+------------+-------------+--------------+
Stranded PyRanges object has 3 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.print(formatting={"Start": "{:,}", "Score": "{:.2f}"})
+--------------+-----------+-----------+------------+-------------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (float64) | (category) |
|--------------+-----------+-----------+------------+-------------+--------------|
| chr1 | 3 | 6 | i1 | 1.1 | + |
| chr1 | 8 | 9 | i3 | 2.4 | + |
| chr1 | 5,000 | 7000 | i2 | 6 | - |
+--------------+-----------+-----------+------------+-------------+--------------+
Stranded PyRanges object has 3 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.print(merge_position=True) # gr.mp()
+--------------------+------------+-------------+
| - Position - | Name | Score |
| (Multiple types) | (object) | (float64) |
|--------------------+------------+-------------|
| chr1 3-6 + | i1 | 1.1 |
| chr1 8-9 + | i3 | 2.3987 |
| chr1 5000-7000 - | i2 | 6 |
+--------------------+------------+-------------+
Stranded PyRanges object has 3 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> chipseq = pr.data.chipseq()
>>> chipseq
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 212609534 | 212609559 | U0 | 0 | + |
| chr1 | 169887529 | 169887554 | U0 | 0 | + |
| chr1 | 216711011 | 216711036 | U0 | 0 | + |
| chr1 | 144227079 | 144227104 | U0 | 0 | + |
| ... | ... | ... | ... | ... | ... |
| chrY | 15224235 | 15224260 | U0 | 0 | - |
| chrY | 13517892 | 13517917 | U0 | 0 | - |
| chrY | 8010951 | 8010976 | U0 | 0 | - |
| chrY | 7405376 | 7405401 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 10,000 rows and 6 columns from 24 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
To interleave strands in output, use print with `sort=True`:
>>> chipseq.print(sort=True, n=20) # chipseq.sp()
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 1325303 | 1325328 | U0 | 0 | - |
| chr1 | 1541598 | 1541623 | U0 | 0 | + |
| chr1 | 1599121 | 1599146 | U0 | 0 | + |
| chr1 | 1820285 | 1820310 | U0 | 0 | - |
| chr1 | 2448322 | 2448347 | U0 | 0 | - |
| chr1 | 3046141 | 3046166 | U0 | 0 | - |
| chr1 | 3437168 | 3437193 | U0 | 0 | - |
| chr1 | 3504032 | 3504057 | U0 | 0 | + |
| chr1 | 3637087 | 3637112 | U0 | 0 | - |
| chr1 | 3681903 | 3681928 | U0 | 0 | - |
| ... | ... | ... | ... | ... | ... |
| chrY | 15224235 | 15224260 | U0 | 0 | - |
| chrY | 15548022 | 15548047 | U0 | 0 | + |
| chrY | 16045242 | 16045267 | U0 | 0 | - |
| chrY | 16495497 | 16495522 | U0 | 0 | - |
| chrY | 21559181 | 21559206 | U0 | 0 | + |
| chrY | 21707662 | 21707687 | U0 | 0 | - |
| chrY | 21751211 | 21751236 | U0 | 0 | - |
| chrY | 21910706 | 21910731 | U0 | 0 | - |
| chrY | 22054002 | 22054027 | U0 | 0 | - |
| chrY | 22210637 | 22210662 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 10,000 rows and 6 columns from 24 chromosomes.
For printing, the PyRanges was sorted on Chromosome, Start, End and Strand.
>>> pr.data.chromsizes().print()
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 0 | 249250621 |
| chr2 | 0 | 243199373 |
| chr3 | 0 | 198022430 |
| chr4 | 0 | 191154276 |
| ... | ... | ... |
| chr22 | 0 | 51304566 |
| chrM | 0 | 16571 |
| chrX | 0 | 155270560 |
| chrY | 0 | 59373566 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 25 rows and 3 columns from 25 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
"""
s = tostring(self, n=n, merge_position=merge_position, sort=sort, formatting=formatting)
print(s)
if chain:
return self
|
Print the PyRanges.
Parameters
----------
n : int, default 8
The number of rows to print.
merge_postion : bool, default False
Print location in same column to save screen space.
sort : bool or str, default False
Sort the PyRanges before printing. Will print chromosomsomes or strands interleaved on
sort columns.
formatting : dict, default None
Formatting options per column.
chain : False
Return the PyRanges. Useful to print intermediate results in call chains.
See Also
--------
PyRanges.pc : print chain
PyRanges.sp : sort print
PyRanges.mp : merge print
PyRanges.spc : sort print chain
PyRanges.mpc : merge print chain
PyRanges.msp : merge sort print
PyRanges.mspc : merge sort print chain
PyRanges.rp : raw print dictionary of DataFrames
Examples
--------
>>> d = {'Chromosome': ['chr1', 'chr1', 'chr1'], 'Start': [3, 8, 5000],
... 'End': [6, 9, 7000], 'Name': ['i1', 'i3', 'i2'],
... 'Score': [1.1, 2.3987, 5.9999995], 'Strand': ['+', '+', '-']}
>>> gr = pr.from_dict(d)
>>> gr
+--------------+-----------+-----------+------------+-------------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (float64) | (category) |
|--------------+-----------+-----------+------------+-------------+--------------|
| chr1 | 3 | 6 | i1 | 1.1 | + |
| chr1 | 8 | 9 | i3 | 2.3987 | + |
| chr1 | 5000 | 7000 | i2 | 6 | - |
+--------------+-----------+-----------+------------+-------------+--------------+
Stranded PyRanges object has 3 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.print(formatting={"Start": "{:,}", "Score": "{:.2f}"})
+--------------+-----------+-----------+------------+-------------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (float64) | (category) |
|--------------+-----------+-----------+------------+-------------+--------------|
| chr1 | 3 | 6 | i1 | 1.1 | + |
| chr1 | 8 | 9 | i3 | 2.4 | + |
| chr1 | 5,000 | 7000 | i2 | 6 | - |
+--------------+-----------+-----------+------------+-------------+--------------+
Stranded PyRanges object has 3 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.print(merge_position=True) # gr.mp()
+--------------------+------------+-------------+
| - Position - | Name | Score |
| (Multiple types) | (object) | (float64) |
|--------------------+------------+-------------|
| chr1 3-6 + | i1 | 1.1 |
| chr1 8-9 + | i3 | 2.3987 |
| chr1 5000-7000 - | i2 | 6 |
+--------------------+------------+-------------+
Stranded PyRanges object has 3 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> chipseq = pr.data.chipseq()
>>> chipseq
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 212609534 | 212609559 | U0 | 0 | + |
| chr1 | 169887529 | 169887554 | U0 | 0 | + |
| chr1 | 216711011 | 216711036 | U0 | 0 | + |
| chr1 | 144227079 | 144227104 | U0 | 0 | + |
| ... | ... | ... | ... | ... | ... |
| chrY | 15224235 | 15224260 | U0 | 0 | - |
| chrY | 13517892 | 13517917 | U0 | 0 | - |
| chrY | 8010951 | 8010976 | U0 | 0 | - |
| chrY | 7405376 | 7405401 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 10,000 rows and 6 columns from 24 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
To interleave strands in output, use print with `sort=True`:
>>> chipseq.print(sort=True, n=20) # chipseq.sp()
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 1325303 | 1325328 | U0 | 0 | - |
| chr1 | 1541598 | 1541623 | U0 | 0 | + |
| chr1 | 1599121 | 1599146 | U0 | 0 | + |
| chr1 | 1820285 | 1820310 | U0 | 0 | - |
| chr1 | 2448322 | 2448347 | U0 | 0 | - |
| chr1 | 3046141 | 3046166 | U0 | 0 | - |
| chr1 | 3437168 | 3437193 | U0 | 0 | - |
| chr1 | 3504032 | 3504057 | U0 | 0 | + |
| chr1 | 3637087 | 3637112 | U0 | 0 | - |
| chr1 | 3681903 | 3681928 | U0 | 0 | - |
| ... | ... | ... | ... | ... | ... |
| chrY | 15224235 | 15224260 | U0 | 0 | - |
| chrY | 15548022 | 15548047 | U0 | 0 | + |
| chrY | 16045242 | 16045267 | U0 | 0 | - |
| chrY | 16495497 | 16495522 | U0 | 0 | - |
| chrY | 21559181 | 21559206 | U0 | 0 | + |
| chrY | 21707662 | 21707687 | U0 | 0 | - |
| chrY | 21751211 | 21751236 | U0 | 0 | - |
| chrY | 21910706 | 21910731 | U0 | 0 | - |
| chrY | 22054002 | 22054027 | U0 | 0 | - |
| chrY | 22210637 | 22210662 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 10,000 rows and 6 columns from 24 chromosomes.
For printing, the PyRanges was sorted on Chromosome, Start, End and Strand.
>>> pr.data.chromsizes().print()
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 0 | 249250621 |
| chr2 | 0 | 243199373 |
| chr3 | 0 | 198022430 |
| chr4 | 0 | 191154276 |
| ... | ... | ... |
| chr22 | 0 | 51304566 |
| chrM | 0 | 16571 |
| chrX | 0 | 155270560 |
| chrY | 0 | 59373566 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 25 rows and 3 columns from 25 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
|
print
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def sample(self, n=8, replace=False):
"""Subsample arbitrary rows of PyRanges.
If n is larger than length of PyRanges, replace must be True.
Parameters
----------
n : int, default 8
Number of rows to return
replace : bool, False
Reuse rows.
Examples
--------
>>> gr = pr.data.chipseq()
>>> np.random.seed(0)
>>> gr.sample(n=3)
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr2 | 76564764 | 76564789 | U0 | 0 | + |
| chr3 | 185739979 | 185740004 | U0 | 0 | - |
| chr20 | 40373657 | 40373682 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 3 rows and 6 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.sample(10001)
Traceback (most recent call last):
...
ValueError: Cannot take a larger sample than population when 'replace=False'
"""
sample = np.random.choice(len(self), size=n, replace=replace)
subsetter = np.zeros(len(self), dtype=np.bool_)
subsetter[sample] = True
return self[subsetter]
|
Subsample arbitrary rows of PyRanges.
If n is larger than length of PyRanges, replace must be True.
Parameters
----------
n : int, default 8
Number of rows to return
replace : bool, False
Reuse rows.
Examples
--------
>>> gr = pr.data.chipseq()
>>> np.random.seed(0)
>>> gr.sample(n=3)
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr2 | 76564764 | 76564789 | U0 | 0 | + |
| chr3 | 185739979 | 185740004 | U0 | 0 | - |
| chr20 | 40373657 | 40373682 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 3 rows and 6 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.sample(10001)
Traceback (most recent call last):
...
ValueError: Cannot take a larger sample than population when 'replace=False'
|
sample
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def set_intersect(self, other, strandedness=None, how=None, new_pos=False, nb_cpu=1):
"""Return set-theoretical intersection.
Like intersect, but both PyRanges are merged first.
Parameters
----------
other : PyRanges
PyRanges to set-intersect.
strandedness : {None, "same", "opposite", False}, default None, i.e. auto
Whether to compare PyRanges on the same strand, the opposite or ignore strand
information. The default, None, means use "same" if both PyRanges are strande,
otherwise ignore the strand information.
how : {None, "first", "last", "containment"}, default None, i.e. all
What intervals to report. By default, reports all overlapping intervals. "containment"
reports intervals where the overlapping is contained within it.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
PyRanges
A PyRanges with overlapping subintervals.
See also
--------
PyRanges.intersect : find overlapping subintervals
PyRanges.overlap : report overlapping intervals
Examples
--------
>>> gr = pr.from_dict({"Chromosome": ["chr1"] * 3, "Start": [1, 4, 10],
... "End": [3, 9, 11], "ID": ["a", "b", "c"]})
>>> gr
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 1 | 3 | a |
| chr1 | 4 | 9 | b |
| chr1 | 10 | 11 | c |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr2 = pr.from_dict({"Chromosome": ["chr1"] * 3, "Start": [2, 2, 9], "End": [3, 9, 10]})
>>> gr2
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 2 | 3 |
| chr1 | 2 | 9 |
| chr1 | 9 | 10 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.set_intersect(gr2)
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 2 | 3 |
| chr1 | 4 | 9 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
In this simple unstranded case, this is the same as the below:
>>> gr.merge().intersect(gr2.merge())
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 2 | 3 |
| chr1 | 4 | 9 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.set_intersect(gr2, how="containment")
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 4 | 9 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 1 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
"""
kwargs = {
"strandedness": strandedness,
"how": how,
"nb_cpu": nb_cpu,
"new_pos": new_pos,
}
kwargs = fill_kwargs(kwargs)
strand = True if strandedness else False
self_clusters = self.merge(strand=strand)
other_clusters = other.merge(strand=strand)
dfs = pyrange_apply(_intersection, self_clusters, other_clusters, **kwargs)
return PyRanges(dfs)
|
Return set-theoretical intersection.
Like intersect, but both PyRanges are merged first.
Parameters
----------
other : PyRanges
PyRanges to set-intersect.
strandedness : {None, "same", "opposite", False}, default None, i.e. auto
Whether to compare PyRanges on the same strand, the opposite or ignore strand
information. The default, None, means use "same" if both PyRanges are strande,
otherwise ignore the strand information.
how : {None, "first", "last", "containment"}, default None, i.e. all
What intervals to report. By default, reports all overlapping intervals. "containment"
reports intervals where the overlapping is contained within it.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
PyRanges
A PyRanges with overlapping subintervals.
See also
--------
PyRanges.intersect : find overlapping subintervals
PyRanges.overlap : report overlapping intervals
Examples
--------
>>> gr = pr.from_dict({"Chromosome": ["chr1"] * 3, "Start": [1, 4, 10],
... "End": [3, 9, 11], "ID": ["a", "b", "c"]})
>>> gr
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 1 | 3 | a |
| chr1 | 4 | 9 | b |
| chr1 | 10 | 11 | c |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr2 = pr.from_dict({"Chromosome": ["chr1"] * 3, "Start": [2, 2, 9], "End": [3, 9, 10]})
>>> gr2
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 2 | 3 |
| chr1 | 2 | 9 |
| chr1 | 9 | 10 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.set_intersect(gr2)
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 2 | 3 |
| chr1 | 4 | 9 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
In this simple unstranded case, this is the same as the below:
>>> gr.merge().intersect(gr2.merge())
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 2 | 3 |
| chr1 | 4 | 9 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.set_intersect(gr2, how="containment")
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 4 | 9 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 1 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
|
set_intersect
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def set_union(self, other, strandedness=None, nb_cpu=1):
"""Return set-theoretical union.
Parameters
----------
other : PyRanges
PyRanges to do union with.
strandedness : {None, "same", "opposite", False}, default None, i.e. auto
Whether to compare PyRanges on the same strand, the opposite or ignore strand
information. The default, None, means use "same" if both PyRanges are strande,
otherwise ignore the strand information.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
PyRanges
A PyRanges with the union of intervals.
See also
--------
PyRanges.set_intersect : set-theoretical intersection
PyRanges.overlap : report overlapping intervals
Examples
--------
>>> gr = pr.from_dict({"Chromosome": ["chr1"] * 3, "Start": [1, 4, 10],
... "End": [3, 9, 11], "ID": ["a", "b", "c"]})
>>> gr
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 1 | 3 | a |
| chr1 | 4 | 9 | b |
| chr1 | 10 | 11 | c |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr2 = pr.from_dict({"Chromosome": ["chr1"] * 3, "Start": [2, 2, 9], "End": [3, 9, 10]})
>>> gr2
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 2 | 3 |
| chr1 | 2 | 9 |
| chr1 | 9 | 10 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.set_union(gr2)
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 1 | 11 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 1 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
"""
if self.empty and other.empty:
return pr.PyRanges()
strand = True if strandedness else False
if not strand:
self = self.unstrand()
other = other.unstrand()
if strandedness == "opposite" and len(other):
other = other.copy()
other.Strand = other.Strand.replace({"+": "-", "-": "+"})
gr = pr.concat([self, other], strand)
gr = gr.merge(strand=strand)
return gr
|
Return set-theoretical union.
Parameters
----------
other : PyRanges
PyRanges to do union with.
strandedness : {None, "same", "opposite", False}, default None, i.e. auto
Whether to compare PyRanges on the same strand, the opposite or ignore strand
information. The default, None, means use "same" if both PyRanges are strande,
otherwise ignore the strand information.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
PyRanges
A PyRanges with the union of intervals.
See also
--------
PyRanges.set_intersect : set-theoretical intersection
PyRanges.overlap : report overlapping intervals
Examples
--------
>>> gr = pr.from_dict({"Chromosome": ["chr1"] * 3, "Start": [1, 4, 10],
... "End": [3, 9, 11], "ID": ["a", "b", "c"]})
>>> gr
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 1 | 3 | a |
| chr1 | 4 | 9 | b |
| chr1 | 10 | 11 | c |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr2 = pr.from_dict({"Chromosome": ["chr1"] * 3, "Start": [2, 2, 9], "End": [3, 9, 10]})
>>> gr2
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 2 | 3 |
| chr1 | 2 | 9 |
| chr1 | 9 | 10 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.set_union(gr2)
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 1 | 11 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 1 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
|
set_union
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def sort(self, by=None, nb_cpu=1):
"""Sort by position or columns.
Parameters
----------
by : str or list of str, default None
Column(s) to sort by. Default is Start and End.
Special value "5" can be provided to sort by 5': intervals on + strand are sorted in ascending order, while
those on - strand are sorted in descending order.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Note
----
Since a PyRanges contains multiple DataFrames, the sorting only happens within dataframes.
Returns
-------
PyRanges
Sorted PyRanges
See Also
--------
pyranges.multioverlap : find overlaps with multiple PyRanges
Examples
--------
>>> p = pr.from_dict({"Chromosome": [1, 1, 1, 1, 1, 1],
... "Strand": ["+", "+", "-", "-", "+", "+"],
... "Start": [40, 1, 10, 70, 140, 160],
... "End": [60, 11, 25, 80, 152, 190],
... "transcript_id":["t3", "t3", "t2", "t2", "t1", "t1"] })
By default, intervals are sorted by position:
>>> p.sort()
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 1 | 11 | t3 |
| 1 | + | 40 | 60 | t3 |
| 1 | + | 140 | 152 | t1 |
| 1 | + | 160 | 190 | t1 |
| 1 | - | 10 | 25 | t2 |
| 1 | - | 70 | 80 | t2 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 6 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
(Note how sorting takes place within Chromosome-Strand pairs.)
To sort according to a specified column:
>>> p.sort(by='transcript_id')
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 140 | 152 | t1 |
| 1 | + | 160 | 190 | t1 |
| 1 | + | 40 | 60 | t3 |
| 1 | + | 1 | 11 | t3 |
| 1 | - | 10 | 25 | t2 |
| 1 | - | 70 | 80 | t2 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 6 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
If the special value "5" is provided, intervals are sorted
according to their five-prime end:
>>> p.sort("5")
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 1 | 11 | t3 |
| 1 | + | 40 | 60 | t3 |
| 1 | + | 140 | 152 | t1 |
| 1 | + | 160 | 190 | t1 |
| 1 | - | 70 | 80 | t2 |
| 1 | - | 10 | 25 | t2 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 6 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
from pyranges.methods.sort import _sort
kwargs = {"strand": self.stranded}
kwargs["sparse"] = {"self": False}
if by:
assert "5" not in by or (
((type(by) is str and by == "5") or (type(by) is not str and "5" in by)) and self.stranded
), "Only stranded PyRanges can be sorted by 5'! "
kwargs["by"] = by
kwargs = fill_kwargs(kwargs)
return PyRanges(pyrange_apply_single(_sort, self, **kwargs))
|
Sort by position or columns.
Parameters
----------
by : str or list of str, default None
Column(s) to sort by. Default is Start and End.
Special value "5" can be provided to sort by 5': intervals on + strand are sorted in ascending order, while
those on - strand are sorted in descending order.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Note
----
Since a PyRanges contains multiple DataFrames, the sorting only happens within dataframes.
Returns
-------
PyRanges
Sorted PyRanges
See Also
--------
pyranges.multioverlap : find overlaps with multiple PyRanges
Examples
--------
>>> p = pr.from_dict({"Chromosome": [1, 1, 1, 1, 1, 1],
... "Strand": ["+", "+", "-", "-", "+", "+"],
... "Start": [40, 1, 10, 70, 140, 160],
... "End": [60, 11, 25, 80, 152, 190],
... "transcript_id":["t3", "t3", "t2", "t2", "t1", "t1"] })
By default, intervals are sorted by position:
>>> p.sort()
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 1 | 11 | t3 |
| 1 | + | 40 | 60 | t3 |
| 1 | + | 140 | 152 | t1 |
| 1 | + | 160 | 190 | t1 |
| 1 | - | 10 | 25 | t2 |
| 1 | - | 70 | 80 | t2 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 6 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
(Note how sorting takes place within Chromosome-Strand pairs.)
To sort according to a specified column:
>>> p.sort(by='transcript_id')
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 140 | 152 | t1 |
| 1 | + | 160 | 190 | t1 |
| 1 | + | 40 | 60 | t3 |
| 1 | + | 1 | 11 | t3 |
| 1 | - | 10 | 25 | t2 |
| 1 | - | 70 | 80 | t2 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 6 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
If the special value "5" is provided, intervals are sorted
according to their five-prime end:
>>> p.sort("5")
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 1 | 11 | t3 |
| 1 | + | 40 | 60 | t3 |
| 1 | + | 140 | 152 | t1 |
| 1 | + | 160 | 190 | t1 |
| 1 | - | 70 | 80 | t2 |
| 1 | - | 10 | 25 | t2 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 6 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
sort
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def spliced_subsequence(self, start=0, end=None, by=None, strand=None, **kwargs):
"""Get subsequences of the intervals, using coordinates mapping to spliced transcripts (without introns)
The returned intervals are subregions of self, cut according to specifications.
Start and end are relative to the 5' end: 0 means the leftmost nucleotide for + strand
intervals, while it means the rightmost one for - strand.
This method also allows to manipulate groups of intervals (e.g. exons belonging to same transcripts)
through the 'by' argument. When using it, start and end refer to the spliced transcript coordinates,
meaning that introns are ignored in the count.
Parameters
----------
start : int
Start of subregion, 0-based and included, counting from the 5' end.
Use a negative int to count from the 3' (e.g. -1 is the last nucleotide)
end : int, default None
End of subregion, 0-based and excluded, counting from the 5' end.
Use a negative int to count from the 3' (e.g. -1 is the last nucleotide)
If None, the existing 3' end is returned.
by : list of str, default None
intervals are grouped by this/these ID column(s) beforehand, e.g. exons belonging to same transcripts
strand : bool, default None, i.e. auto
Whether strand is considered when interpreting the start and end arguments of this function.
If True, counting is from the 5' end, which is the leftmost coordinate for + strand and the rightmost for - strand.
If False, all intervals are processed like they reside on the + strand.
If None (default), strand is considered if the PyRanges is stranded.
Returns
-------
PyRanges
Subregion of self, subsequenced as specified by arguments
Note
----
If the request goes out of bounds (e.g. requesting 100 nts for a 90nt region), only the existing portion is returned
See also
--------
subsequence : analogous to this method, but input coordinates refer to the unspliced transcript
Examples
--------
>>> p = pr.from_dict({"Chromosome": [1, 1, 2, 2, 3],
... "Strand": ["+", "+", "-", "-", "+"],
... "Start": [1, 40, 10, 70, 140],
... "End": [11, 60, 25, 80, 152],
... "transcript_id":["t1", "t1", "t2", "t2", "t3"] })
>>> p
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 1 | 11 | t1 |
| 1 | + | 40 | 60 | t1 |
| 2 | - | 10 | 25 | t2 |
| 2 | - | 70 | 80 | t2 |
| 3 | + | 140 | 152 | t3 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 5 rows and 5 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
# Get the first 15 nucleotides of *each spliced transcript*, grouping exons by transcript_id:
>>> p.spliced_subsequence(0, 15, by='transcript_id')
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 1 | 11 | t1 |
| 1 | + | 40 | 45 | t1 |
| 2 | - | 70 | 80 | t2 |
| 2 | - | 20 | 25 | t2 |
| 3 | + | 140 | 152 | t3 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 5 rows and 5 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
# Get the last 20 nucleotides of each spliced transcript:
>>> p.spliced_subsequence(-20, by='transcript_id')
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 40 | 60 | t1 |
| 2 | - | 70 | 75 | t2 |
| 2 | - | 10 | 25 | t2 |
| 3 | + | 140 | 152 | t3 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 4 rows and 5 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
# Get region from 25 to 60 of each spliced transcript, or their existing subportion:
>>> p.spliced_subsequence(25, 60, by='transcript_id')
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 55 | 60 | t1 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 1 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
# Get region of each spliced transcript which excludes their first and last 3 nucleotides:
>>> p.spliced_subsequence(3, -3, by='transcript_id')
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 4 | 11 | t1 |
| 1 | + | 40 | 57 | t1 |
| 2 | - | 70 | 77 | t2 |
| 2 | - | 13 | 25 | t2 |
| 3 | + | 143 | 149 | t3 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 5 rows and 5 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
from pyranges.methods.spliced_subsequence import _spliced_subseq
if strand and not self.stranded:
raise Exception("spliced_subsequence: you can use strand=True only for stranded PyRanges!")
if strand is None:
strand = True if self.stranded else False
kwargs.update({"strand": strand, "by": by, "start": start, "end": end})
kwargs = fill_kwargs(kwargs)
if not strand:
sorted_p = self.sort()
else:
sorted_p = self.sort("5")
result = pyrange_apply_single(_spliced_subseq, sorted_p, **kwargs)
return pr.PyRanges(result)
|
Get subsequences of the intervals, using coordinates mapping to spliced transcripts (without introns)
The returned intervals are subregions of self, cut according to specifications.
Start and end are relative to the 5' end: 0 means the leftmost nucleotide for + strand
intervals, while it means the rightmost one for - strand.
This method also allows to manipulate groups of intervals (e.g. exons belonging to same transcripts)
through the 'by' argument. When using it, start and end refer to the spliced transcript coordinates,
meaning that introns are ignored in the count.
Parameters
----------
start : int
Start of subregion, 0-based and included, counting from the 5' end.
Use a negative int to count from the 3' (e.g. -1 is the last nucleotide)
end : int, default None
End of subregion, 0-based and excluded, counting from the 5' end.
Use a negative int to count from the 3' (e.g. -1 is the last nucleotide)
If None, the existing 3' end is returned.
by : list of str, default None
intervals are grouped by this/these ID column(s) beforehand, e.g. exons belonging to same transcripts
strand : bool, default None, i.e. auto
Whether strand is considered when interpreting the start and end arguments of this function.
If True, counting is from the 5' end, which is the leftmost coordinate for + strand and the rightmost for - strand.
If False, all intervals are processed like they reside on the + strand.
If None (default), strand is considered if the PyRanges is stranded.
Returns
-------
PyRanges
Subregion of self, subsequenced as specified by arguments
Note
----
If the request goes out of bounds (e.g. requesting 100 nts for a 90nt region), only the existing portion is returned
See also
--------
subsequence : analogous to this method, but input coordinates refer to the unspliced transcript
Examples
--------
>>> p = pr.from_dict({"Chromosome": [1, 1, 2, 2, 3],
... "Strand": ["+", "+", "-", "-", "+"],
... "Start": [1, 40, 10, 70, 140],
... "End": [11, 60, 25, 80, 152],
... "transcript_id":["t1", "t1", "t2", "t2", "t3"] })
>>> p
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 1 | 11 | t1 |
| 1 | + | 40 | 60 | t1 |
| 2 | - | 10 | 25 | t2 |
| 2 | - | 70 | 80 | t2 |
| 3 | + | 140 | 152 | t3 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 5 rows and 5 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
# Get the first 15 nucleotides of *each spliced transcript*, grouping exons by transcript_id:
>>> p.spliced_subsequence(0, 15, by='transcript_id')
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 1 | 11 | t1 |
| 1 | + | 40 | 45 | t1 |
| 2 | - | 70 | 80 | t2 |
| 2 | - | 20 | 25 | t2 |
| 3 | + | 140 | 152 | t3 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 5 rows and 5 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
# Get the last 20 nucleotides of each spliced transcript:
>>> p.spliced_subsequence(-20, by='transcript_id')
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 40 | 60 | t1 |
| 2 | - | 70 | 75 | t2 |
| 2 | - | 10 | 25 | t2 |
| 3 | + | 140 | 152 | t3 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 4 rows and 5 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
# Get region from 25 to 60 of each spliced transcript, or their existing subportion:
>>> p.spliced_subsequence(25, 60, by='transcript_id')
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 55 | 60 | t1 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 1 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
# Get region of each spliced transcript which excludes their first and last 3 nucleotides:
>>> p.spliced_subsequence(3, -3, by='transcript_id')
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 4 | 11 | t1 |
| 1 | + | 40 | 57 | t1 |
| 2 | - | 70 | 77 | t2 |
| 2 | - | 13 | 25 | t2 |
| 3 | + | 143 | 149 | t3 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 5 rows and 5 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
spliced_subsequence
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def split(self, strand=None, between=False, nb_cpu=1):
"""Split into non-overlapping intervals.
Parameters
----------
strand : bool, default None, i.e. auto
Whether to ignore strand information if PyRanges is stranded.
between : bool, default False
Include lengths between intervals.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
PyRanges
PyRanges with intervals split at overlap points.
See Also
--------
pyranges.multioverlap : find overlaps with multiple PyRanges
Examples
--------
>>> d = {'Chromosome': ['chr1', 'chr1', 'chr1', 'chr1'], 'Start': [3, 5, 5, 11],
... 'End': [6, 9, 7, 12], 'Strand': ['+', '+', '-', '-']}
>>> gr = pr.from_dict(d)
>>> gr
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 3 | 6 | + |
| chr1 | 5 | 9 | + |
| chr1 | 5 | 7 | - |
| chr1 | 11 | 12 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 4 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.split()
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | Strand |
| (object) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 3 | 5 | + |
| chr1 | 5 | 6 | + |
| chr1 | 6 | 9 | + |
| chr1 | 5 | 7 | - |
| chr1 | 11 | 12 | - |
+--------------+-----------+-----------+------------+
Stranded PyRanges object has 5 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.split(between=True)
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | Strand |
| (object) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 3 | 5 | + |
| chr1 | 5 | 6 | + |
| chr1 | 6 | 9 | + |
| chr1 | 5 | 7 | - |
| chr1 | 7 | 11 | - |
| chr1 | 11 | 12 | - |
+--------------+-----------+-----------+------------+
Stranded PyRanges object has 6 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.split(strand=False)
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (object) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 3 | 5 |
| chr1 | 5 | 6 |
| chr1 | 6 | 7 |
| chr1 | 7 | 9 |
| chr1 | 11 | 12 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 5 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.split(strand=False, between=True)
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (object) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 3 | 5 |
| chr1 | 5 | 6 |
| chr1 | 6 | 7 |
| chr1 | 7 | 9 |
| chr1 | 9 | 11 |
| chr1 | 11 | 12 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 6 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
"""
if strand is None:
strand = self.stranded
kwargs = fill_kwargs({"strand": strand})
from pyranges.methods.split import _split
df = pyrange_apply_single(_split, self, **kwargs)
split = pr.PyRanges(df)
if not between:
strandedness = "same" if strand else False
split = split.overlap(self, strandedness=strandedness)
return split
|
Split into non-overlapping intervals.
Parameters
----------
strand : bool, default None, i.e. auto
Whether to ignore strand information if PyRanges is stranded.
between : bool, default False
Include lengths between intervals.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
PyRanges
PyRanges with intervals split at overlap points.
See Also
--------
pyranges.multioverlap : find overlaps with multiple PyRanges
Examples
--------
>>> d = {'Chromosome': ['chr1', 'chr1', 'chr1', 'chr1'], 'Start': [3, 5, 5, 11],
... 'End': [6, 9, 7, 12], 'Strand': ['+', '+', '-', '-']}
>>> gr = pr.from_dict(d)
>>> gr
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 3 | 6 | + |
| chr1 | 5 | 9 | + |
| chr1 | 5 | 7 | - |
| chr1 | 11 | 12 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 4 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.split()
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | Strand |
| (object) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 3 | 5 | + |
| chr1 | 5 | 6 | + |
| chr1 | 6 | 9 | + |
| chr1 | 5 | 7 | - |
| chr1 | 11 | 12 | - |
+--------------+-----------+-----------+------------+
Stranded PyRanges object has 5 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.split(between=True)
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | Strand |
| (object) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 3 | 5 | + |
| chr1 | 5 | 6 | + |
| chr1 | 6 | 9 | + |
| chr1 | 5 | 7 | - |
| chr1 | 7 | 11 | - |
| chr1 | 11 | 12 | - |
+--------------+-----------+-----------+------------+
Stranded PyRanges object has 6 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.split(strand=False)
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (object) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 3 | 5 |
| chr1 | 5 | 6 |
| chr1 | 6 | 7 |
| chr1 | 7 | 9 |
| chr1 | 11 | 12 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 5 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.split(strand=False, between=True)
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (object) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 3 | 5 |
| chr1 | 5 | 6 |
| chr1 | 6 | 7 |
| chr1 | 7 | 9 |
| chr1 | 9 | 11 |
| chr1 | 11 | 12 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 6 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
|
split
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def stranded(self):
"""Whether PyRanges has (valid) strand info.
Note
----
A PyRanges can have invalid values in the Strand-column. It is not considered stranded.
See Also
--------
PyRanges.strands : return the strands
Examples
--------
>>> d = {'Chromosome': ['chr1', 'chr1'], 'Start': [1, 6],
... 'End': [5, 8], 'Strand': ['+', '.']}
>>> gr = pr.from_dict(d)
>>> gr
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 1 | 5 | + |
| chr1 | 6 | 8 | . |
+--------------+-----------+-----------+--------------+
Unstranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
Considered unstranded due to these Strand values: '.'
>>> gr.stranded
False
>>> "Strand" in gr.columns
True
"""
keys = self.keys()
if not len(keys):
# so that stranded ops work with empty dataframes
return True
key = keys[0]
return isinstance(key, tuple)
|
Whether PyRanges has (valid) strand info.
Note
----
A PyRanges can have invalid values in the Strand-column. It is not considered stranded.
See Also
--------
PyRanges.strands : return the strands
Examples
--------
>>> d = {'Chromosome': ['chr1', 'chr1'], 'Start': [1, 6],
... 'End': [5, 8], 'Strand': ['+', '.']}
>>> gr = pr.from_dict(d)
>>> gr
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 1 | 5 | + |
| chr1 | 6 | 8 | . |
+--------------+-----------+-----------+--------------+
Unstranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
Considered unstranded due to these Strand values: '.'
>>> gr.stranded
False
>>> "Strand" in gr.columns
True
|
stranded
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def strands(self):
"""Return strands.
Notes
-----
If the strand-column contains an invalid value, [] is returned.
See Also
--------
PyRanges.stranded : whether has valid strand info
Examples
--------
>>> d = {'Chromosome': ['chr1', 'chr1'], 'Start': [1, 6],
... 'End': [5, 8], 'Strand': ['+', '.']}
>>> gr = pr.from_dict(d)
>>> gr
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 1 | 5 | + |
| chr1 | 6 | 8 | . |
+--------------+-----------+-----------+--------------+
Unstranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
Considered unstranded due to these Strand values: '.'
>>> gr.strands
[]
>>> gr.Strand.drop_duplicates().to_list()
['+', '.']
>>> gr.Strand = ["+", "-"]
>>> gr.strands
['+', '-']
"""
if not self.stranded:
return []
return natsorted(set([k[1] for k in self.keys()]))
|
Return strands.
Notes
-----
If the strand-column contains an invalid value, [] is returned.
See Also
--------
PyRanges.stranded : whether has valid strand info
Examples
--------
>>> d = {'Chromosome': ['chr1', 'chr1'], 'Start': [1, 6],
... 'End': [5, 8], 'Strand': ['+', '.']}
>>> gr = pr.from_dict(d)
>>> gr
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 1 | 5 | + |
| chr1 | 6 | 8 | . |
+--------------+-----------+-----------+--------------+
Unstranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
Considered unstranded due to these Strand values: '.'
>>> gr.strands
[]
>>> gr.Strand.drop_duplicates().to_list()
['+', '.']
>>> gr.Strand = ["+", "-"]
>>> gr.strands
['+', '-']
|
strands
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def subset(self, f, strand=None, **kwargs):
"""Return a subset of the rows.
Parameters
----------
f : function
Function which returns boolean Series equal to length of df.
strand : bool, default None, i.e. auto
Whether to do operations on chromosome/strand pairs or chromosomes. If None, will use
chromosome/strand pairs if the PyRanges is stranded.
nb_cpu : int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
**kwargs
Additional keyword arguments to pass as keyword arguments to `f`
Notes
-----
PyRanges can also be subsetted directly with a boolean Series. This function is slightly
faster, but more cumbersome.
Returns
-------
PyRanges
PyRanges subset on rows.
Examples
--------
>>> gr = pr.data.f1()
>>> gr
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 3 | 6 | interval1 | 0 | + |
| chr1 | 8 | 9 | interval3 | 0 | + |
| chr1 | 5 | 7 | interval2 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 3 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.subset(lambda df: df.Start > 4)
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 8 | 9 | interval3 | 0 | + |
| chr1 | 5 | 7 | interval2 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 2 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
Also possible:
>>> gr[gr.Start > 4]
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 8 | 9 | interval3 | 0 | + |
| chr1 | 5 | 7 | interval2 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 2 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
kwargs = fill_kwargs(kwargs)
if strand is None:
strand = self.stranded
if self.stranded and not strand:
self = self.unstrand()
kwargs.update({"strand": strand})
result = pyrange_apply_single(f, self, **kwargs)
if not result:
return pr.PyRanges()
first_result = next(iter(result.values()))
assert first_result.dtype == bool, "result of subset function must be bool, but is {}".format(
first_result.dtype
)
return self[result]
|
Return a subset of the rows.
Parameters
----------
f : function
Function which returns boolean Series equal to length of df.
strand : bool, default None, i.e. auto
Whether to do operations on chromosome/strand pairs or chromosomes. If None, will use
chromosome/strand pairs if the PyRanges is stranded.
nb_cpu : int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
**kwargs
Additional keyword arguments to pass as keyword arguments to `f`
Notes
-----
PyRanges can also be subsetted directly with a boolean Series. This function is slightly
faster, but more cumbersome.
Returns
-------
PyRanges
PyRanges subset on rows.
Examples
--------
>>> gr = pr.data.f1()
>>> gr
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 3 | 6 | interval1 | 0 | + |
| chr1 | 8 | 9 | interval3 | 0 | + |
| chr1 | 5 | 7 | interval2 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 3 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.subset(lambda df: df.Start > 4)
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 8 | 9 | interval3 | 0 | + |
| chr1 | 5 | 7 | interval2 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 2 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
Also possible:
>>> gr[gr.Start > 4]
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 8 | 9 | interval3 | 0 | + |
| chr1 | 5 | 7 | interval2 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 2 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
subset
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def subsequence(self, start=0, end=None, by=None, strand=None, **kwargs):
"""Get subsequences of the intervals.
The returned intervals are subregions of self, cut according to specifications.
Start and end are relative to the 5' end: 0 means the leftmost nucleotide for + strand
intervals, while it means the rightmost one for - strand.
This method also allows to manipulate groups of intervals (e.g. exons belonging to same transcripts)
through the 'by' argument. When using it, start and end refer to the unspliced transcript coordinates,
meaning that introns are included in the count.
Parameters
----------
start : int
Start of subregion, 0-based and included, counting from the 5' end.
Use a negative int to count from the 3' (e.g. -1 is the last nucleotide)
end : int, default None
End of subregion, 0-based and excluded, counting from the 5' end.
Use a negative int to count from the 3' (e.g. -1 is the last nucleotide)
If None, the existing 3' end is returned.
by : list of str, default None
intervals are grouped by this/these ID column(s) beforehand, e.g. exons belonging to same transcripts
strand : bool, default None, i.e. auto
Whether strand is considered when interpreting the start and end arguments of this function.
If True, counting is from the 5' end, which is the leftmost coordinate for + strand and the rightmost for - strand.
If False, all intervals are processed like they reside on the + strand.
If None (default), strand is considered if the PyRanges is stranded.
Returns
-------
PyRanges
Subregion of self, subsequenced as specified by arguments
Note
----
If the request goes out of bounds (e.g. requesting 100 nts for a 90nt region), only the existing portion is returned
See also
--------
spliced_subsequence : analogous to this method, but intronic regions are not counted, so that input coordinates refer to the spliced transcript
Examples
--------
>>> p = pr.from_dict({"Chromosome": [1, 1, 2, 2, 3],
... "Strand": ["+", "+", "-", "-", "+"],
... "Start": [1, 40, 2, 30, 140],
... "End": [20, 60, 13, 45, 155],
... "transcript_id":["t1", "t1", "t2", "t2", "t3"] })
>>> p
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 1 | 20 | t1 |
| 1 | + | 40 | 60 | t1 |
| 2 | - | 2 | 13 | t2 |
| 2 | - | 30 | 45 | t2 |
| 3 | + | 140 | 155 | t3 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 5 rows and 5 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
# Get the first 10 nucleotides (at the 5') of *each interval* (each line of the dataframe):
>>> p.subsequence(0, 10)
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 1 | 11 | t1 |
| 1 | + | 40 | 50 | t1 |
| 2 | - | 3 | 13 | t2 |
| 2 | - | 35 | 45 | t2 |
| 3 | + | 140 | 150 | t3 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 5 rows and 5 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
# Get the first 10 nucleotides of *each transcript*, grouping exons by transcript_id:
>>> p.subsequence(0, 10, by='transcript_id')
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 1 | 11 | t1 |
| 2 | - | 35 | 45 | t2 |
| 3 | + | 140 | 150 | t3 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 3 rows and 5 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
# Get the last 20 nucleotides of each transcript:
>>> p.subsequence(-20, by='transcript_id')
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 40 | 60 | t1 |
| 2 | - | 2 | 13 | t2 |
| 3 | + | 140 | 155 | t3 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 3 rows and 5 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
# Get region from 30 to 330 of each transcript, or their existing subportion:
>>> p.subsequence(30, 300, by='transcript_id')
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 40 | 60 | t1 |
| 2 | - | 2 | 13 | t2 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 2 rows and 5 columns from 2 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
from pyranges.methods.subsequence import _subseq
if strand is None:
strand = True if self.stranded else False
kwargs.update({"strand": strand, "by": by, "start": start, "end": end})
kwargs = fill_kwargs(kwargs)
result = pyrange_apply_single(_subseq, self, **kwargs)
return pr.PyRanges(result)
|
Get subsequences of the intervals.
The returned intervals are subregions of self, cut according to specifications.
Start and end are relative to the 5' end: 0 means the leftmost nucleotide for + strand
intervals, while it means the rightmost one for - strand.
This method also allows to manipulate groups of intervals (e.g. exons belonging to same transcripts)
through the 'by' argument. When using it, start and end refer to the unspliced transcript coordinates,
meaning that introns are included in the count.
Parameters
----------
start : int
Start of subregion, 0-based and included, counting from the 5' end.
Use a negative int to count from the 3' (e.g. -1 is the last nucleotide)
end : int, default None
End of subregion, 0-based and excluded, counting from the 5' end.
Use a negative int to count from the 3' (e.g. -1 is the last nucleotide)
If None, the existing 3' end is returned.
by : list of str, default None
intervals are grouped by this/these ID column(s) beforehand, e.g. exons belonging to same transcripts
strand : bool, default None, i.e. auto
Whether strand is considered when interpreting the start and end arguments of this function.
If True, counting is from the 5' end, which is the leftmost coordinate for + strand and the rightmost for - strand.
If False, all intervals are processed like they reside on the + strand.
If None (default), strand is considered if the PyRanges is stranded.
Returns
-------
PyRanges
Subregion of self, subsequenced as specified by arguments
Note
----
If the request goes out of bounds (e.g. requesting 100 nts for a 90nt region), only the existing portion is returned
See also
--------
spliced_subsequence : analogous to this method, but intronic regions are not counted, so that input coordinates refer to the spliced transcript
Examples
--------
>>> p = pr.from_dict({"Chromosome": [1, 1, 2, 2, 3],
... "Strand": ["+", "+", "-", "-", "+"],
... "Start": [1, 40, 2, 30, 140],
... "End": [20, 60, 13, 45, 155],
... "transcript_id":["t1", "t1", "t2", "t2", "t3"] })
>>> p
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 1 | 20 | t1 |
| 1 | + | 40 | 60 | t1 |
| 2 | - | 2 | 13 | t2 |
| 2 | - | 30 | 45 | t2 |
| 3 | + | 140 | 155 | t3 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 5 rows and 5 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
# Get the first 10 nucleotides (at the 5') of *each interval* (each line of the dataframe):
>>> p.subsequence(0, 10)
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 1 | 11 | t1 |
| 1 | + | 40 | 50 | t1 |
| 2 | - | 3 | 13 | t2 |
| 2 | - | 35 | 45 | t2 |
| 3 | + | 140 | 150 | t3 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 5 rows and 5 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
# Get the first 10 nucleotides of *each transcript*, grouping exons by transcript_id:
>>> p.subsequence(0, 10, by='transcript_id')
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 1 | 11 | t1 |
| 2 | - | 35 | 45 | t2 |
| 3 | + | 140 | 150 | t3 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 3 rows and 5 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
# Get the last 20 nucleotides of each transcript:
>>> p.subsequence(-20, by='transcript_id')
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 40 | 60 | t1 |
| 2 | - | 2 | 13 | t2 |
| 3 | + | 140 | 155 | t3 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 3 rows and 5 columns from 3 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
# Get region from 30 to 330 of each transcript, or their existing subportion:
>>> p.subsequence(30, 300, by='transcript_id')
+--------------+--------------+-----------+-----------+-----------------+
| Chromosome | Strand | Start | End | transcript_id |
| (category) | (category) | (int64) | (int64) | (object) |
|--------------+--------------+-----------+-----------+-----------------|
| 1 | + | 40 | 60 | t1 |
| 2 | - | 2 | 13 | t2 |
+--------------+--------------+-----------+-----------+-----------------+
Stranded PyRanges object has 2 rows and 5 columns from 2 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
subsequence
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def subtract(self, other, strandedness=None, nb_cpu=1):
"""Subtract intervals.
Parameters
----------
strandedness : {None, "same", "opposite", False}, default None, i.e. auto
Whether to compare PyRanges on the same strand, the opposite or ignore strand
information. The default, None, means use "same" if both PyRanges are strande,
otherwise ignore the strand information.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
See Also
--------
pyranges.PyRanges.overlap : use with invert=True to return all intervals without overlap
Examples
--------
>>> gr = pr.from_dict({"Chromosome": ["chr1"] * 3, "Start": [1, 4, 10],
... "End": [3, 9, 11], "ID": ["a", "b", "c"]})
>>> gr2 = pr.from_dict({"Chromosome": ["chr1"] * 3, "Start": [2, 2, 9], "End": [3, 9, 10]})
>>> gr
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 1 | 3 | a |
| chr1 | 4 | 9 | b |
| chr1 | 10 | 11 | c |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr2
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 2 | 3 |
| chr1 | 2 | 9 |
| chr1 | 9 | 10 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.subtract(gr2)
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 1 | 2 | a |
| chr1 | 10 | 11 | c |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
"""
from pyranges.methods.subtraction import _subtraction
kwargs = {"strandedness": strandedness}
kwargs["sparse"] = {"self": False, "other": True}
kwargs = fill_kwargs(kwargs)
strand = True if strandedness else False
other_clusters = other.merge(strand=strand)
self = self.count_overlaps(other_clusters, strandedness=strandedness, overlap_col="__num__")
result = pyrange_apply(_subtraction, self, other_clusters, **kwargs)
self = self.drop("__num__")
return PyRanges(result).drop("__num__")
|
Subtract intervals.
Parameters
----------
strandedness : {None, "same", "opposite", False}, default None, i.e. auto
Whether to compare PyRanges on the same strand, the opposite or ignore strand
information. The default, None, means use "same" if both PyRanges are strande,
otherwise ignore the strand information.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
See Also
--------
pyranges.PyRanges.overlap : use with invert=True to return all intervals without overlap
Examples
--------
>>> gr = pr.from_dict({"Chromosome": ["chr1"] * 3, "Start": [1, 4, 10],
... "End": [3, 9, 11], "ID": ["a", "b", "c"]})
>>> gr2 = pr.from_dict({"Chromosome": ["chr1"] * 3, "Start": [2, 2, 9], "End": [3, 9, 10]})
>>> gr
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 1 | 3 | a |
| chr1 | 4 | 9 | b |
| chr1 | 10 | 11 | c |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 3 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr2
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 2 | 3 |
| chr1 | 2 | 9 |
| chr1 | 9 | 10 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 3 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.subtract(gr2)
+--------------+-----------+-----------+------------+
| Chromosome | Start | End | ID |
| (category) | (int64) | (int64) | (object) |
|--------------+-----------+-----------+------------|
| chr1 | 1 | 2 | a |
| chr1 | 10 | 11 | c |
+--------------+-----------+-----------+------------+
Unstranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
|
subtract
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def summary(self, to_stdout=True, return_df=False):
"""Return info.
Count refers to the number of intervals, the rest to the lengths.
The column "pyrange" describes the data as is. "coverage_forward" and "coverage_reverse"
describe the data after strand-specific merging of overlapping intervals.
"coverage_unstranded" describes the data after merging, without considering the strands.
The row "count" is the number of intervals and "sum" is their total length. The rest describe the lengths of the
intervals.
Parameters
----------
to_stdout : bool, default True
Print summary.
return_df : bool, default False
Return df with summary.
Returns
-------
None or DataFrame with summary.
Examples
--------
>>> gr = pr.data.ensembl_gtf()[["Feature", "gene_id"]]
>>> gr
+--------------+--------------+-----------+-----------+--------------+-----------------+
| Chromosome | Feature | Start | End | Strand | gene_id |
| (category) | (category) | (int64) | (int64) | (category) | (object) |
|--------------+--------------+-----------+-----------+--------------+-----------------|
| 1 | gene | 11868 | 14409 | + | ENSG00000223972 |
| 1 | transcript | 11868 | 14409 | + | ENSG00000223972 |
| 1 | exon | 11868 | 12227 | + | ENSG00000223972 |
| 1 | exon | 12612 | 12721 | + | ENSG00000223972 |
| ... | ... | ... | ... | ... | ... |
| 1 | gene | 1173055 | 1179555 | - | ENSG00000205231 |
| 1 | transcript | 1173055 | 1179555 | - | ENSG00000205231 |
| 1 | exon | 1179364 | 1179555 | - | ENSG00000205231 |
| 1 | exon | 1173055 | 1176396 | - | ENSG00000205231 |
+--------------+--------------+-----------+-----------+--------------+-----------------+
Stranded PyRanges object has 2,446 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.summary()
+-------+------------------+--------------------+--------------------+-----------------------+
| | pyrange | coverage_forward | coverage_reverse | coverage_unstranded |
|-------+------------------+--------------------+--------------------+-----------------------|
| count | 2446 | 39 | 23 | 32 |
| mean | 2291.92 | 7058.1 | 30078.6 | 27704.2 |
| std | 11906.9 | 10322.3 | 59467.7 | 67026.9 |
| min | 1 | 83 | 154 | 83 |
| 25% | 90 | 1051 | 1204 | 1155 |
| 50% | 138 | 2541 | 6500 | 6343 |
| 75% | 382.25 | 7168 | 23778 | 20650.8 |
| max | 241726 | 43065 | 241726 | 291164 |
| sum | 5.60603e+06 | 275266 | 691807 | 886534 |
+-------+------------------+--------------------+--------------------+-----------------------+
>>> gr.summary(return_df=True, to_stdout=False)
pyrange coverage_forward coverage_reverse coverage_unstranded
count 2.446000e+03 39.000000 23.000000 32.000000
mean 2.291918e+03 7058.102564 30078.565217 27704.187500
std 1.190685e+04 10322.309347 59467.695265 67026.868647
min 1.000000e+00 83.000000 154.000000 83.000000
25% 9.000000e+01 1051.000000 1204.000000 1155.000000
50% 1.380000e+02 2541.000000 6500.000000 6343.000000
75% 3.822500e+02 7168.000000 23778.000000 20650.750000
max 2.417260e+05 43065.000000 241726.000000 291164.000000
sum 5.606031e+06 275266.000000 691807.000000 886534.000000
"""
from pyranges.methods.summary import _summary
return _summary(self, to_stdout, return_df)
|
Return info.
Count refers to the number of intervals, the rest to the lengths.
The column "pyrange" describes the data as is. "coverage_forward" and "coverage_reverse"
describe the data after strand-specific merging of overlapping intervals.
"coverage_unstranded" describes the data after merging, without considering the strands.
The row "count" is the number of intervals and "sum" is their total length. The rest describe the lengths of the
intervals.
Parameters
----------
to_stdout : bool, default True
Print summary.
return_df : bool, default False
Return df with summary.
Returns
-------
None or DataFrame with summary.
Examples
--------
>>> gr = pr.data.ensembl_gtf()[["Feature", "gene_id"]]
>>> gr
+--------------+--------------+-----------+-----------+--------------+-----------------+
| Chromosome | Feature | Start | End | Strand | gene_id |
| (category) | (category) | (int64) | (int64) | (category) | (object) |
|--------------+--------------+-----------+-----------+--------------+-----------------|
| 1 | gene | 11868 | 14409 | + | ENSG00000223972 |
| 1 | transcript | 11868 | 14409 | + | ENSG00000223972 |
| 1 | exon | 11868 | 12227 | + | ENSG00000223972 |
| 1 | exon | 12612 | 12721 | + | ENSG00000223972 |
| ... | ... | ... | ... | ... | ... |
| 1 | gene | 1173055 | 1179555 | - | ENSG00000205231 |
| 1 | transcript | 1173055 | 1179555 | - | ENSG00000205231 |
| 1 | exon | 1179364 | 1179555 | - | ENSG00000205231 |
| 1 | exon | 1173055 | 1176396 | - | ENSG00000205231 |
+--------------+--------------+-----------+-----------+--------------+-----------------+
Stranded PyRanges object has 2,446 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.summary()
+-------+------------------+--------------------+--------------------+-----------------------+
| | pyrange | coverage_forward | coverage_reverse | coverage_unstranded |
|-------+------------------+--------------------+--------------------+-----------------------|
| count | 2446 | 39 | 23 | 32 |
| mean | 2291.92 | 7058.1 | 30078.6 | 27704.2 |
| std | 11906.9 | 10322.3 | 59467.7 | 67026.9 |
| min | 1 | 83 | 154 | 83 |
| 25% | 90 | 1051 | 1204 | 1155 |
| 50% | 138 | 2541 | 6500 | 6343 |
| 75% | 382.25 | 7168 | 23778 | 20650.8 |
| max | 241726 | 43065 | 241726 | 291164 |
| sum | 5.60603e+06 | 275266 | 691807 | 886534 |
+-------+------------------+--------------------+--------------------+-----------------------+
>>> gr.summary(return_df=True, to_stdout=False)
pyrange coverage_forward coverage_reverse coverage_unstranded
count 2.446000e+03 39.000000 23.000000 32.000000
mean 2.291918e+03 7058.102564 30078.565217 27704.187500
std 1.190685e+04 10322.309347 59467.695265 67026.868647
min 1.000000e+00 83.000000 154.000000 83.000000
25% 9.000000e+01 1051.000000 1204.000000 1155.000000
50% 1.380000e+02 2541.000000 6500.000000 6343.000000
75% 3.822500e+02 7168.000000 23778.000000 20650.750000
max 2.417260e+05 43065.000000 241726.000000 291164.000000
sum 5.606031e+06 275266.000000 691807.000000 886534.000000
|
summary
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def tail(self, n=8):
"""Return the n last rows.
Parameters
----------
n : int, default 8
Return n rows.
Returns
-------
PyRanges
PyRanges with the n last rows.
See Also
--------
PyRanges.head : return the first rows
PyRanges.sample : return random rows
Examples
--------
>>> gr = pr.data.chipseq()
>>> gr
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 212609534 | 212609559 | U0 | 0 | + |
| chr1 | 169887529 | 169887554 | U0 | 0 | + |
| chr1 | 216711011 | 216711036 | U0 | 0 | + |
| chr1 | 144227079 | 144227104 | U0 | 0 | + |
| ... | ... | ... | ... | ... | ... |
| chrY | 15224235 | 15224260 | U0 | 0 | - |
| chrY | 13517892 | 13517917 | U0 | 0 | - |
| chrY | 8010951 | 8010976 | U0 | 0 | - |
| chrY | 7405376 | 7405401 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 10,000 rows and 6 columns from 24 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.tail(3)
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chrY | 13517892 | 13517917 | U0 | 0 | - |
| chrY | 8010951 | 8010976 | U0 | 0 | - |
| chrY | 7405376 | 7405401 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 3 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
subsetter = np.zeros(len(self), dtype=np.bool_)
subsetter[(len(self) - n) :] = True
return self[subsetter]
|
Return the n last rows.
Parameters
----------
n : int, default 8
Return n rows.
Returns
-------
PyRanges
PyRanges with the n last rows.
See Also
--------
PyRanges.head : return the first rows
PyRanges.sample : return random rows
Examples
--------
>>> gr = pr.data.chipseq()
>>> gr
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 212609534 | 212609559 | U0 | 0 | + |
| chr1 | 169887529 | 169887554 | U0 | 0 | + |
| chr1 | 216711011 | 216711036 | U0 | 0 | + |
| chr1 | 144227079 | 144227104 | U0 | 0 | + |
| ... | ... | ... | ... | ... | ... |
| chrY | 15224235 | 15224260 | U0 | 0 | - |
| chrY | 13517892 | 13517917 | U0 | 0 | - |
| chrY | 8010951 | 8010976 | U0 | 0 | - |
| chrY | 7405376 | 7405401 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 10,000 rows and 6 columns from 24 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.tail(3)
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chrY | 13517892 | 13517917 | U0 | 0 | - |
| chrY | 8010951 | 8010976 | U0 | 0 | - |
| chrY | 7405376 | 7405401 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 3 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
tail
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def tile(self, tile_size, overlap=False, strand=None, nb_cpu=1):
"""Return overlapping genomic tiles.
The genome is divided into bookended tiles of length `tile_size` and one is returned per
overlapping interval.
Parameters
----------
tile_size : int
Length of the tiles.
overlap : bool, default False
Add column of nucleotide overlap to each tile.
strand : bool, default None, i.e. auto
Whether to do operations on chromosome/strand pairs or chromosomes. If None, will use
chromosome/strand pairs if the PyRanges is stranded.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
**kwargs
Additional keyword arguments to pass as keyword arguments to `f`
Returns
-------
PyRanges
Tiled PyRanges.
See also
--------
pyranges.PyRanges.window : divide intervals into windows
Examples
--------
>>> gr = pr.data.ensembl_gtf()[["Feature", "gene_name"]]
>>> gr
+--------------+--------------+-----------+-----------+--------------+-------------+
| Chromosome | Feature | Start | End | Strand | gene_name |
| (category) | (category) | (int64) | (int64) | (category) | (object) |
|--------------+--------------+-----------+-----------+--------------+-------------|
| 1 | gene | 11868 | 14409 | + | DDX11L1 |
| 1 | transcript | 11868 | 14409 | + | DDX11L1 |
| 1 | exon | 11868 | 12227 | + | DDX11L1 |
| 1 | exon | 12612 | 12721 | + | DDX11L1 |
| ... | ... | ... | ... | ... | ... |
| 1 | gene | 1173055 | 1179555 | - | TTLL10-AS1 |
| 1 | transcript | 1173055 | 1179555 | - | TTLL10-AS1 |
| 1 | exon | 1179364 | 1179555 | - | TTLL10-AS1 |
| 1 | exon | 1173055 | 1176396 | - | TTLL10-AS1 |
+--------------+--------------+-----------+-----------+--------------+-------------+
Stranded PyRanges object has 2,446 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.tile(200)
+--------------+--------------+-----------+-----------+--------------+-------------+
| Chromosome | Feature | Start | End | Strand | gene_name |
| (category) | (category) | (int64) | (int64) | (category) | (object) |
|--------------+--------------+-----------+-----------+--------------+-------------|
| 1 | gene | 11800 | 12000 | + | DDX11L1 |
| 1 | gene | 12000 | 12200 | + | DDX11L1 |
| 1 | gene | 12200 | 12400 | + | DDX11L1 |
| 1 | gene | 12400 | 12600 | + | DDX11L1 |
| ... | ... | ... | ... | ... | ... |
| 1 | exon | 1175600 | 1175800 | - | TTLL10-AS1 |
| 1 | exon | 1175800 | 1176000 | - | TTLL10-AS1 |
| 1 | exon | 1176000 | 1176200 | - | TTLL10-AS1 |
| 1 | exon | 1176200 | 1176400 | - | TTLL10-AS1 |
+--------------+--------------+-----------+-----------+--------------+-------------+
Stranded PyRanges object has 30,538 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.tile(100, overlap=True)
+--------------+--------------+-----------+-----------+--------------+-------------+---------------+
| Chromosome | Feature | Start | End | Strand | gene_name | TileOverlap |
| (category) | (category) | (int64) | (int64) | (category) | (object) | (int64) |
|--------------+--------------+-----------+-----------+--------------+-------------+---------------|
| 1 | gene | 11800 | 11900 | + | DDX11L1 | 32 |
| 1 | gene | 11900 | 12000 | + | DDX11L1 | 100 |
| 1 | gene | 12000 | 12100 | + | DDX11L1 | 100 |
| 1 | gene | 12100 | 12200 | + | DDX11L1 | 100 |
| ... | ... | ... | ... | ... | ... | ... |
| 1 | exon | 1176000 | 1176100 | - | TTLL10-AS1 | 100 |
| 1 | exon | 1176100 | 1176200 | - | TTLL10-AS1 | 100 |
| 1 | exon | 1176200 | 1176300 | - | TTLL10-AS1 | 100 |
| 1 | exon | 1176300 | 1176400 | - | TTLL10-AS1 | 96 |
+--------------+--------------+-----------+-----------+--------------+-------------+---------------+
Stranded PyRanges object has 58,516 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
from pyranges.methods.windows import _tiles
if strand is None:
strand = self.stranded
kwargs = {"strand": strand, "overlap": overlap}
kwargs["sparse"] = {"self": False}
kwargs["tile_size"] = tile_size
df = pyrange_apply_single(_tiles, self, **kwargs)
return PyRanges(df)
|
Return overlapping genomic tiles.
The genome is divided into bookended tiles of length `tile_size` and one is returned per
overlapping interval.
Parameters
----------
tile_size : int
Length of the tiles.
overlap : bool, default False
Add column of nucleotide overlap to each tile.
strand : bool, default None, i.e. auto
Whether to do operations on chromosome/strand pairs or chromosomes. If None, will use
chromosome/strand pairs if the PyRanges is stranded.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
**kwargs
Additional keyword arguments to pass as keyword arguments to `f`
Returns
-------
PyRanges
Tiled PyRanges.
See also
--------
pyranges.PyRanges.window : divide intervals into windows
Examples
--------
>>> gr = pr.data.ensembl_gtf()[["Feature", "gene_name"]]
>>> gr
+--------------+--------------+-----------+-----------+--------------+-------------+
| Chromosome | Feature | Start | End | Strand | gene_name |
| (category) | (category) | (int64) | (int64) | (category) | (object) |
|--------------+--------------+-----------+-----------+--------------+-------------|
| 1 | gene | 11868 | 14409 | + | DDX11L1 |
| 1 | transcript | 11868 | 14409 | + | DDX11L1 |
| 1 | exon | 11868 | 12227 | + | DDX11L1 |
| 1 | exon | 12612 | 12721 | + | DDX11L1 |
| ... | ... | ... | ... | ... | ... |
| 1 | gene | 1173055 | 1179555 | - | TTLL10-AS1 |
| 1 | transcript | 1173055 | 1179555 | - | TTLL10-AS1 |
| 1 | exon | 1179364 | 1179555 | - | TTLL10-AS1 |
| 1 | exon | 1173055 | 1176396 | - | TTLL10-AS1 |
+--------------+--------------+-----------+-----------+--------------+-------------+
Stranded PyRanges object has 2,446 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.tile(200)
+--------------+--------------+-----------+-----------+--------------+-------------+
| Chromosome | Feature | Start | End | Strand | gene_name |
| (category) | (category) | (int64) | (int64) | (category) | (object) |
|--------------+--------------+-----------+-----------+--------------+-------------|
| 1 | gene | 11800 | 12000 | + | DDX11L1 |
| 1 | gene | 12000 | 12200 | + | DDX11L1 |
| 1 | gene | 12200 | 12400 | + | DDX11L1 |
| 1 | gene | 12400 | 12600 | + | DDX11L1 |
| ... | ... | ... | ... | ... | ... |
| 1 | exon | 1175600 | 1175800 | - | TTLL10-AS1 |
| 1 | exon | 1175800 | 1176000 | - | TTLL10-AS1 |
| 1 | exon | 1176000 | 1176200 | - | TTLL10-AS1 |
| 1 | exon | 1176200 | 1176400 | - | TTLL10-AS1 |
+--------------+--------------+-----------+-----------+--------------+-------------+
Stranded PyRanges object has 30,538 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.tile(100, overlap=True)
+--------------+--------------+-----------+-----------+--------------+-------------+---------------+
| Chromosome | Feature | Start | End | Strand | gene_name | TileOverlap |
| (category) | (category) | (int64) | (int64) | (category) | (object) | (int64) |
|--------------+--------------+-----------+-----------+--------------+-------------+---------------|
| 1 | gene | 11800 | 11900 | + | DDX11L1 | 32 |
| 1 | gene | 11900 | 12000 | + | DDX11L1 | 100 |
| 1 | gene | 12000 | 12100 | + | DDX11L1 | 100 |
| 1 | gene | 12100 | 12200 | + | DDX11L1 | 100 |
| ... | ... | ... | ... | ... | ... | ... |
| 1 | exon | 1176000 | 1176100 | - | TTLL10-AS1 | 100 |
| 1 | exon | 1176100 | 1176200 | - | TTLL10-AS1 | 100 |
| 1 | exon | 1176200 | 1176300 | - | TTLL10-AS1 | 100 |
| 1 | exon | 1176300 | 1176400 | - | TTLL10-AS1 | 96 |
+--------------+--------------+-----------+-----------+--------------+-------------+---------------+
Stranded PyRanges object has 58,516 rows and 7 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
tile
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def to_example(self, n=10):
"""Return as dict.
Used for easily creating examples for copy and pasting.
Parameters
----------
n : int, default 10
Number of rows. Half is taken from the start, the other half from the end.
See Also
--------
PyRanges.from_dict : create PyRanges from dict
Examples
--------
>>> gr = pr.data.chipseq()
>>> gr
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 212609534 | 212609559 | U0 | 0 | + |
| chr1 | 169887529 | 169887554 | U0 | 0 | + |
| chr1 | 216711011 | 216711036 | U0 | 0 | + |
| chr1 | 144227079 | 144227104 | U0 | 0 | + |
| ... | ... | ... | ... | ... | ... |
| chrY | 15224235 | 15224260 | U0 | 0 | - |
| chrY | 13517892 | 13517917 | U0 | 0 | - |
| chrY | 8010951 | 8010976 | U0 | 0 | - |
| chrY | 7405376 | 7405401 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 10,000 rows and 6 columns from 24 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> d = gr.to_example(n=4)
>>> d
{'Chromosome': ['chr1', 'chr1', 'chrY', 'chrY'], 'Start': [212609534, 169887529, 8010951, 7405376], 'End': [212609559, 169887554, 8010976, 7405401], 'Name': ['U0', 'U0', 'U0', 'U0'], 'Score': [0, 0, 0, 0], 'Strand': ['+', '+', '-', '-']}
>>> pr.from_dict(d)
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 212609534 | 212609559 | U0 | 0 | + |
| chr1 | 169887529 | 169887554 | U0 | 0 | + |
| chrY | 8010951 | 8010976 | U0 | 0 | - |
| chrY | 7405376 | 7405401 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 4 rows and 6 columns from 2 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
nrows_half = int(min(n, len(self)) / 2)
if n < len(self):
first = self.head(nrows_half)
last = self.tail(nrows_half)
example = pr.concat([first, last])
else:
example = self
d = {c: list(getattr(example, c)) for c in example.columns}
return d
|
Return as dict.
Used for easily creating examples for copy and pasting.
Parameters
----------
n : int, default 10
Number of rows. Half is taken from the start, the other half from the end.
See Also
--------
PyRanges.from_dict : create PyRanges from dict
Examples
--------
>>> gr = pr.data.chipseq()
>>> gr
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 212609534 | 212609559 | U0 | 0 | + |
| chr1 | 169887529 | 169887554 | U0 | 0 | + |
| chr1 | 216711011 | 216711036 | U0 | 0 | + |
| chr1 | 144227079 | 144227104 | U0 | 0 | + |
| ... | ... | ... | ... | ... | ... |
| chrY | 15224235 | 15224260 | U0 | 0 | - |
| chrY | 13517892 | 13517917 | U0 | 0 | - |
| chrY | 8010951 | 8010976 | U0 | 0 | - |
| chrY | 7405376 | 7405401 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 10,000 rows and 6 columns from 24 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> d = gr.to_example(n=4)
>>> d
{'Chromosome': ['chr1', 'chr1', 'chrY', 'chrY'], 'Start': [212609534, 169887529, 8010951, 7405376], 'End': [212609559, 169887554, 8010976, 7405401], 'Name': ['U0', 'U0', 'U0', 'U0'], 'Score': [0, 0, 0, 0], 'Strand': ['+', '+', '-', '-']}
>>> pr.from_dict(d)
+--------------+-----------+-----------+------------+-----------+--------------+
| Chromosome | Start | End | Name | Score | Strand |
| (category) | (int64) | (int64) | (object) | (int64) | (category) |
|--------------+-----------+-----------+------------+-----------+--------------|
| chr1 | 212609534 | 212609559 | U0 | 0 | + |
| chr1 | 169887529 | 169887554 | U0 | 0 | + |
| chrY | 8010951 | 8010976 | U0 | 0 | - |
| chrY | 7405376 | 7405401 | U0 | 0 | - |
+--------------+-----------+-----------+------------+-----------+--------------+
Stranded PyRanges object has 4 rows and 6 columns from 2 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
to_example
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def three_end(self):
"""Return the 3'-end.
The 3'-end is the start of intervals on the reverse strand and the end of intervals on the
forward strand.
Returns
-------
PyRanges
PyRanges with the 3'.
See Also
--------
PyRanges.five_end : return the five prime end
Examples
--------
>>> d = {'Chromosome': ['chr1', 'chr1'], 'Start': [1, 6],
... 'End': [5, 8], 'Strand': ['+', '-']}
>>> gr = pr.from_dict(d)
>>> gr
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 1 | 5 | + |
| chr1 | 6 | 8 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.three_end()
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 4 | 5 | + |
| chr1 | 6 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
assert self.stranded, "Need stranded pyrange to find 3'."
kwargs = fill_kwargs({"strand": True})
return PyRanges(pyrange_apply_single(_tes, self, **kwargs))
|
Return the 3'-end.
The 3'-end is the start of intervals on the reverse strand and the end of intervals on the
forward strand.
Returns
-------
PyRanges
PyRanges with the 3'.
See Also
--------
PyRanges.five_end : return the five prime end
Examples
--------
>>> d = {'Chromosome': ['chr1', 'chr1'], 'Start': [1, 6],
... 'End': [5, 8], 'Strand': ['+', '-']}
>>> gr = pr.from_dict(d)
>>> gr
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 1 | 5 | + |
| chr1 | 6 | 8 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.three_end()
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 4 | 5 | + |
| chr1 | 6 | 7 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
three_end
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def to_bed(self, path=None, keep=True, compression="infer", chain=False):
r"""Write to bed.
Parameters
----------
path : str, default None
Where to write. If None, returns string representation.
keep : bool, default True
Whether to keep all columns, not just Chromosome, Start, End,
Name, Score, Strand when writing.
compression : str, compression type to use, by default infer based on extension.
See pandas.DataFree.to_csv for more info.
chain : bool, default False
Whether to return the PyRanges after writing.
Examples
--------
>>> d = {'Chromosome': ['chr1', 'chr1'], 'Start': [1, 6],
... 'End': [5, 8], 'Strand': ['+', '-'], "Gene": [1, 2]}
>>> gr = pr.from_dict(d)
>>> gr
+--------------+-----------+-----------+--------------+-----------+
| Chromosome | Start | End | Strand | Gene |
| (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------|
| chr1 | 1 | 5 | + | 1 |
| chr1 | 6 | 8 | - | 2 |
+--------------+-----------+-----------+--------------+-----------+
Stranded PyRanges object has 2 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.to_bed()
'chr1\t1\t5\t.\t.\t+\t1\nchr1\t6\t8\t.\t.\t-\t2\n'
# File contents:
chr1 1 5 . . + 1
chr1 6 8 . . - 2
Does not include noncanonical bed-column `Gene`:
>>> gr.to_bed(keep=False)
'chr1\t1\t5\t.\t.\t+\nchr1\t6\t8\t.\t.\t-\n'
# File contents:
chr1 1 5 . . +
chr1 6 8 . . -
>>> gr.to_bed("test.bed", chain=True)
+--------------+-----------+-----------+--------------+-----------+
| Chromosome | Start | End | Strand | Gene |
| (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------|
| chr1 | 1 | 5 | + | 1 |
| chr1 | 6 | 8 | - | 2 |
+--------------+-----------+-----------+--------------+-----------+
Stranded PyRanges object has 2 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> open("test.bed").readlines()
['chr1\t1\t5\t.\t.\t+\t1\n', 'chr1\t6\t8\t.\t.\t-\t2\n']
"""
from pyranges.out import _to_bed
result = _to_bed(self, path, keep=keep, compression=compression)
if path and chain:
return self
else:
return result
|
Write to bed.
Parameters
----------
path : str, default None
Where to write. If None, returns string representation.
keep : bool, default True
Whether to keep all columns, not just Chromosome, Start, End,
Name, Score, Strand when writing.
compression : str, compression type to use, by default infer based on extension.
See pandas.DataFree.to_csv for more info.
chain : bool, default False
Whether to return the PyRanges after writing.
Examples
--------
>>> d = {'Chromosome': ['chr1', 'chr1'], 'Start': [1, 6],
... 'End': [5, 8], 'Strand': ['+', '-'], "Gene": [1, 2]}
>>> gr = pr.from_dict(d)
>>> gr
+--------------+-----------+-----------+--------------+-----------+
| Chromosome | Start | End | Strand | Gene |
| (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------|
| chr1 | 1 | 5 | + | 1 |
| chr1 | 6 | 8 | - | 2 |
+--------------+-----------+-----------+--------------+-----------+
Stranded PyRanges object has 2 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.to_bed()
'chr1\t1\t5\t.\t.\t+\t1\nchr1\t6\t8\t.\t.\t-\t2\n'
# File contents:
chr1 1 5 . . + 1
chr1 6 8 . . - 2
Does not include noncanonical bed-column `Gene`:
>>> gr.to_bed(keep=False)
'chr1\t1\t5\t.\t.\t+\nchr1\t6\t8\t.\t.\t-\n'
# File contents:
chr1 1 5 . . +
chr1 6 8 . . -
>>> gr.to_bed("test.bed", chain=True)
+--------------+-----------+-----------+--------------+-----------+
| Chromosome | Start | End | Strand | Gene |
| (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------|
| chr1 | 1 | 5 | + | 1 |
| chr1 | 6 | 8 | - | 2 |
+--------------+-----------+-----------+--------------+-----------+
Stranded PyRanges object has 2 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> open("test.bed").readlines()
['chr1\t1\t5\t.\t.\t+\t1\n', 'chr1\t6\t8\t.\t.\t-\t2\n']
|
to_bed
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def to_bigwig(
self,
path=None,
chromosome_sizes=None,
rpm=True,
divide=None,
value_col=None,
dryrun=False,
chain=False,
):
"""Write regular or value coverage to bigwig.
Note
----
To create one bigwig per strand, subset the PyRanges first.
Parameters
----------
path : str
Where to write bigwig.
chromosome_sizes : PyRanges or dict
If dict: map of chromosome names to chromosome length.
rpm : True
Whether to normalize data by dividing by total number of intervals and multiplying by
1e6.
divide : bool, default False
(Only useful with value_col) Divide value coverage by regular coverage and take log2.
value_col : str, default None
Name of column to compute coverage of.
dryrun : bool, default False
Return data that would be written without writing bigwigs.
chain : bool, default False
Whether to return the PyRanges after writing.
Note
----
Requires pybigwig to be installed.
If you require more control over the normalization process, use pyranges.to_bigwig()
See Also
--------
pyranges.to_bigwig : write pandas DataFrame to bigwig.
Examples
--------
>>> d = {'Chromosome': ['chr1', 'chr1', 'chr1'], 'Start': [1, 4, 6],
... 'End': [7, 8, 10], 'Strand': ['+', '-', '-'],
... 'Value': [10, 20, 30]}
>>> gr = pr.from_dict(d)
>>> gr
+--------------+-----------+-----------+--------------+-----------+
| Chromosome | Start | End | Strand | Value |
| (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------|
| chr1 | 1 | 7 | + | 10 |
| chr1 | 4 | 8 | - | 20 |
| chr1 | 6 | 10 | - | 30 |
+--------------+-----------+-----------+--------------+-----------+
Stranded PyRanges object has 3 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.to_bigwig(dryrun=True, rpm=False)
+--------------+-----------+-----------+-------------+
| Chromosome | Start | End | Score |
| (category) | (int64) | (int64) | (float64) |
|--------------+-----------+-----------+-------------|
| chr1 | 1 | 4 | 1 |
| chr1 | 4 | 6 | 2 |
| chr1 | 6 | 7 | 3 |
| chr1 | 7 | 8 | 2 |
| chr1 | 8 | 10 | 1 |
+--------------+-----------+-----------+-------------+
Unstranded PyRanges object has 5 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.to_bigwig(dryrun=True, rpm=False, value_col="Value")
+--------------+-----------+-----------+-------------+
| Chromosome | Start | End | Score |
| (category) | (int64) | (int64) | (float64) |
|--------------+-----------+-----------+-------------|
| chr1 | 1 | 4 | 10 |
| chr1 | 4 | 6 | 30 |
| chr1 | 6 | 7 | 60 |
| chr1 | 7 | 8 | 50 |
| chr1 | 8 | 10 | 30 |
+--------------+-----------+-----------+-------------+
Unstranded PyRanges object has 5 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.to_bigwig(dryrun=True, rpm=False, value_col="Value", divide=True)
+--------------+-----------+-----------+-------------+
| Chromosome | Start | End | Score |
| (category) | (int64) | (int64) | (float64) |
|--------------+-----------+-----------+-------------|
| chr1 | 0 | 1 | nan |
| chr1 | 1 | 4 | 3.32193 |
| chr1 | 4 | 6 | 3.90689 |
| chr1 | 6 | 7 | 4.32193 |
| chr1 | 7 | 8 | 4.64386 |
| chr1 | 8 | 10 | 4.90689 |
+--------------+-----------+-----------+-------------+
Unstranded PyRanges object has 6 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
"""
from pyranges.out import _to_bigwig
if chromosome_sizes is None:
chromosome_sizes = pr.data.chromsizes()
result = _to_bigwig(self, path, chromosome_sizes, rpm, divide, value_col, dryrun)
if dryrun:
return result
if chain:
return self
else:
pass
|
Write regular or value coverage to bigwig.
Note
----
To create one bigwig per strand, subset the PyRanges first.
Parameters
----------
path : str
Where to write bigwig.
chromosome_sizes : PyRanges or dict
If dict: map of chromosome names to chromosome length.
rpm : True
Whether to normalize data by dividing by total number of intervals and multiplying by
1e6.
divide : bool, default False
(Only useful with value_col) Divide value coverage by regular coverage and take log2.
value_col : str, default None
Name of column to compute coverage of.
dryrun : bool, default False
Return data that would be written without writing bigwigs.
chain : bool, default False
Whether to return the PyRanges after writing.
Note
----
Requires pybigwig to be installed.
If you require more control over the normalization process, use pyranges.to_bigwig()
See Also
--------
pyranges.to_bigwig : write pandas DataFrame to bigwig.
Examples
--------
>>> d = {'Chromosome': ['chr1', 'chr1', 'chr1'], 'Start': [1, 4, 6],
... 'End': [7, 8, 10], 'Strand': ['+', '-', '-'],
... 'Value': [10, 20, 30]}
>>> gr = pr.from_dict(d)
>>> gr
+--------------+-----------+-----------+--------------+-----------+
| Chromosome | Start | End | Strand | Value |
| (category) | (int64) | (int64) | (category) | (int64) |
|--------------+-----------+-----------+--------------+-----------|
| chr1 | 1 | 7 | + | 10 |
| chr1 | 4 | 8 | - | 20 |
| chr1 | 6 | 10 | - | 30 |
+--------------+-----------+-----------+--------------+-----------+
Stranded PyRanges object has 3 rows and 5 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.to_bigwig(dryrun=True, rpm=False)
+--------------+-----------+-----------+-------------+
| Chromosome | Start | End | Score |
| (category) | (int64) | (int64) | (float64) |
|--------------+-----------+-----------+-------------|
| chr1 | 1 | 4 | 1 |
| chr1 | 4 | 6 | 2 |
| chr1 | 6 | 7 | 3 |
| chr1 | 7 | 8 | 2 |
| chr1 | 8 | 10 | 1 |
+--------------+-----------+-----------+-------------+
Unstranded PyRanges object has 5 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.to_bigwig(dryrun=True, rpm=False, value_col="Value")
+--------------+-----------+-----------+-------------+
| Chromosome | Start | End | Score |
| (category) | (int64) | (int64) | (float64) |
|--------------+-----------+-----------+-------------|
| chr1 | 1 | 4 | 10 |
| chr1 | 4 | 6 | 30 |
| chr1 | 6 | 7 | 60 |
| chr1 | 7 | 8 | 50 |
| chr1 | 8 | 10 | 30 |
+--------------+-----------+-----------+-------------+
Unstranded PyRanges object has 5 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.to_bigwig(dryrun=True, rpm=False, value_col="Value", divide=True)
+--------------+-----------+-----------+-------------+
| Chromosome | Start | End | Score |
| (category) | (int64) | (int64) | (float64) |
|--------------+-----------+-----------+-------------|
| chr1 | 0 | 1 | nan |
| chr1 | 1 | 4 | 3.32193 |
| chr1 | 4 | 6 | 3.90689 |
| chr1 | 6 | 7 | 4.32193 |
| chr1 | 7 | 8 | 4.64386 |
| chr1 | 8 | 10 | 4.90689 |
+--------------+-----------+-----------+-------------+
Unstranded PyRanges object has 6 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
|
to_bigwig
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def to_rle(self, value_col=None, strand=None, rpm=False, nb_cpu=1):
"""Return as RleDict.
Create collection of Rles representing the coverage or other numerical value.
Parameters
----------
value_col : str, default None
Numerical column to create RleDict from.
strand : bool, default None, i.e. auto
Whether to treat strands serparately.
rpm : bool, default False
Normalize by multiplying with `1e6/(number_intervals)`.
nb_cpu : int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
pyrle.RleDict
Rle with coverage or other info from the PyRanges.
Examples
--------
>>> d = {'Chromosome': ['chr1', 'chr1', 'chr1'], 'Start': [3, 8, 5],
... 'End': [6, 9, 7], 'Score': [0.1, 5, 3.14], 'Strand': ['+', '+', '-']}
>>> gr = pr.from_dict(d)
>>> gr.to_rle()
chr1 +
--
+--------+-----+-----+-----+-----+
| Runs | 3 | 3 | 2 | 1 |
|--------+-----+-----+-----+-----|
| Values | 0.0 | 1.0 | 0.0 | 1.0 |
+--------+-----+-----+-----+-----+
Rle of length 9 containing 4 elements (avg. length 2.25)
<BLANKLINE>
chr1 -
--
+--------+-----+-----+
| Runs | 5 | 2 |
|--------+-----+-----|
| Values | 0.0 | 1.0 |
+--------+-----+-----+
Rle of length 7 containing 2 elements (avg. length 3.5)
RleDict object with 2 chromosomes/strand pairs.
>>> gr.to_rle(value_col="Score")
chr1 +
--
+--------+-----+-----+-----+-----+
| Runs | 3 | 3 | 2 | 1 |
|--------+-----+-----+-----+-----|
| Values | 0.0 | 0.1 | 0.0 | 5.0 |
+--------+-----+-----+-----+-----+
Rle of length 9 containing 4 elements (avg. length 2.25)
<BLANKLINE>
chr1 -
--
+--------+-----+------+
| Runs | 5 | 2 |
|--------+-----+------|
| Values | 0.0 | 3.14 |
+--------+-----+------+
Rle of length 7 containing 2 elements (avg. length 3.5)
RleDict object with 2 chromosomes/strand pairs.
>>> gr.to_rle(value_col="Score", strand=False)
chr1
+--------+-----+-----+------+------+-----+-----+
| Runs | 3 | 2 | 1 | 1 | 1 | 1 |
|--------+-----+-----+------+------+-----+-----|
| Values | 0.0 | 0.1 | 3.24 | 3.14 | 0.0 | 5.0 |
+--------+-----+-----+------+------+-----+-----+
Rle of length 9 containing 6 elements (avg. length 1.5)
Unstranded RleDict object with 1 chromosome.
>>> gr.to_rle(rpm=True)
chr1 +
--
+--------+-----+-------------------+-----+-------------------+
| Runs | 3 | 3 | 2 | 1 |
|--------+-----+-------------------+-----+-------------------|
| Values | 0.0 | 333333.3333333333 | 0.0 | 333333.3333333333 |
+--------+-----+-------------------+-----+-------------------+
Rle of length 9 containing 4 elements (avg. length 2.25)
<BLANKLINE>
chr1 -
--
+--------+-----+-------------------+
| Runs | 5 | 2 |
|--------+-----+-------------------|
| Values | 0.0 | 333333.3333333333 |
+--------+-----+-------------------+
Rle of length 7 containing 2 elements (avg. length 3.5)
RleDict object with 2 chromosomes/strand pairs.
"""
if strand is None:
strand = self.stranded
from pyranges.methods.to_rle import _to_rle
return _to_rle(self, value_col, strand=strand, rpm=rpm, nb_cpu=nb_cpu)
|
Return as RleDict.
Create collection of Rles representing the coverage or other numerical value.
Parameters
----------
value_col : str, default None
Numerical column to create RleDict from.
strand : bool, default None, i.e. auto
Whether to treat strands serparately.
rpm : bool, default False
Normalize by multiplying with `1e6/(number_intervals)`.
nb_cpu : int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
Returns
-------
pyrle.RleDict
Rle with coverage or other info from the PyRanges.
Examples
--------
>>> d = {'Chromosome': ['chr1', 'chr1', 'chr1'], 'Start': [3, 8, 5],
... 'End': [6, 9, 7], 'Score': [0.1, 5, 3.14], 'Strand': ['+', '+', '-']}
>>> gr = pr.from_dict(d)
>>> gr.to_rle()
chr1 +
--
+--------+-----+-----+-----+-----+
| Runs | 3 | 3 | 2 | 1 |
|--------+-----+-----+-----+-----|
| Values | 0.0 | 1.0 | 0.0 | 1.0 |
+--------+-----+-----+-----+-----+
Rle of length 9 containing 4 elements (avg. length 2.25)
<BLANKLINE>
chr1 -
--
+--------+-----+-----+
| Runs | 5 | 2 |
|--------+-----+-----|
| Values | 0.0 | 1.0 |
+--------+-----+-----+
Rle of length 7 containing 2 elements (avg. length 3.5)
RleDict object with 2 chromosomes/strand pairs.
>>> gr.to_rle(value_col="Score")
chr1 +
--
+--------+-----+-----+-----+-----+
| Runs | 3 | 3 | 2 | 1 |
|--------+-----+-----+-----+-----|
| Values | 0.0 | 0.1 | 0.0 | 5.0 |
+--------+-----+-----+-----+-----+
Rle of length 9 containing 4 elements (avg. length 2.25)
<BLANKLINE>
chr1 -
--
+--------+-----+------+
| Runs | 5 | 2 |
|--------+-----+------|
| Values | 0.0 | 3.14 |
+--------+-----+------+
Rle of length 7 containing 2 elements (avg. length 3.5)
RleDict object with 2 chromosomes/strand pairs.
>>> gr.to_rle(value_col="Score", strand=False)
chr1
+--------+-----+-----+------+------+-----+-----+
| Runs | 3 | 2 | 1 | 1 | 1 | 1 |
|--------+-----+-----+------+------+-----+-----|
| Values | 0.0 | 0.1 | 3.24 | 3.14 | 0.0 | 5.0 |
+--------+-----+-----+------+------+-----+-----+
Rle of length 9 containing 6 elements (avg. length 1.5)
Unstranded RleDict object with 1 chromosome.
>>> gr.to_rle(rpm=True)
chr1 +
--
+--------+-----+-------------------+-----+-------------------+
| Runs | 3 | 3 | 2 | 1 |
|--------+-----+-------------------+-----+-------------------|
| Values | 0.0 | 333333.3333333333 | 0.0 | 333333.3333333333 |
+--------+-----+-------------------+-----+-------------------+
Rle of length 9 containing 4 elements (avg. length 2.25)
<BLANKLINE>
chr1 -
--
+--------+-----+-------------------+
| Runs | 5 | 2 |
|--------+-----+-------------------|
| Values | 0.0 | 333333.3333333333 |
+--------+-----+-------------------+
Rle of length 7 containing 2 elements (avg. length 3.5)
RleDict object with 2 chromosomes/strand pairs.
|
to_rle
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def unstrand(self):
"""Remove strand.
Note
----
Removes Strand column even if PyRanges is not stranded.
See Also
--------
PyRanges.stranded : whether PyRanges contains valid strand info.
Examples
--------
>>> d = {'Chromosome': ['chr1', 'chr1'], 'Start': [1, 6],
... 'End': [5, 8], 'Strand': ['+', '-']}
>>> gr = pr.from_dict(d)
>>> gr
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 1 | 5 | + |
| chr1 | 6 | 8 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.unstrand()
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 1 | 5 |
| chr1 | 6 | 8 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
"""
if not self.stranded and "Strand" in self.columns:
return self.drop("Strand")
elif not self.stranded:
return self
gr = pr.concat([self["+"], self["-"]])
gr = gr.apply(lambda df: df.drop("Strand", axis=1).reset_index(drop=True))
return pr.PyRanges(gr.dfs)
|
Remove strand.
Note
----
Removes Strand column even if PyRanges is not stranded.
See Also
--------
PyRanges.stranded : whether PyRanges contains valid strand info.
Examples
--------
>>> d = {'Chromosome': ['chr1', 'chr1'], 'Start': [1, 6],
... 'End': [5, 8], 'Strand': ['+', '-']}
>>> gr = pr.from_dict(d)
>>> gr
+--------------+-----------+-----------+--------------+
| Chromosome | Start | End | Strand |
| (category) | (int64) | (int64) | (category) |
|--------------+-----------+-----------+--------------|
| chr1 | 1 | 5 | + |
| chr1 | 6 | 8 | - |
+--------------+-----------+-----------+--------------+
Stranded PyRanges object has 2 rows and 4 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr.unstrand()
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| chr1 | 1 | 5 |
| chr1 | 6 | 8 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
|
unstrand
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def window(self, window_size, strand=None):
"""Return overlapping genomic windows.
Windows of length `window_size` are returned.
Parameters
----------
window_size : int
Length of the windows.
strand : bool, default None, i.e. auto
Whether to do operations on chromosome/strand pairs or chromosomes. If None, will use
chromosome/strand pairs if the PyRanges is stranded.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
**kwargs
Additional keyword arguments to pass as keyword arguments to `f`
Returns
-------
PyRanges
Tiled PyRanges.
See also
--------
pyranges.PyRanges.tile : divide intervals into adjacent tiles.
Examples
--------
>>> import pyranges as pr
>>> gr = pr.from_dict({"Chromosome": [1], "Start": [895], "End": [1259]})
>>> gr
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| 1 | 895 | 1259 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 1 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.window(200)
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| 1 | 895 | 1095 |
| 1 | 1095 | 1259 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr2 = pr.data.ensembl_gtf()[["Feature", "gene_name"]]
>>> gr2
+--------------+--------------+-----------+-----------+--------------+-------------+
| Chromosome | Feature | Start | End | Strand | gene_name |
| (category) | (category) | (int64) | (int64) | (category) | (object) |
|--------------+--------------+-----------+-----------+--------------+-------------|
| 1 | gene | 11868 | 14409 | + | DDX11L1 |
| 1 | transcript | 11868 | 14409 | + | DDX11L1 |
| 1 | exon | 11868 | 12227 | + | DDX11L1 |
| 1 | exon | 12612 | 12721 | + | DDX11L1 |
| ... | ... | ... | ... | ... | ... |
| 1 | gene | 1173055 | 1179555 | - | TTLL10-AS1 |
| 1 | transcript | 1173055 | 1179555 | - | TTLL10-AS1 |
| 1 | exon | 1179364 | 1179555 | - | TTLL10-AS1 |
| 1 | exon | 1173055 | 1176396 | - | TTLL10-AS1 |
+--------------+--------------+-----------+-----------+--------------+-------------+
Stranded PyRanges object has 2,446 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr2 = pr.data.ensembl_gtf()[["Feature", "gene_name"]]
>>> gr2.window(1000)
+--------------+--------------+-----------+-----------+--------------+-------------+
| Chromosome | Feature | Start | End | Strand | gene_name |
| (category) | (category) | (int64) | (int64) | (category) | (object) |
|--------------+--------------+-----------+-----------+--------------+-------------|
| 1 | gene | 11868 | 12868 | + | DDX11L1 |
| 1 | gene | 12868 | 13868 | + | DDX11L1 |
| 1 | gene | 13868 | 14409 | + | DDX11L1 |
| 1 | transcript | 11868 | 12868 | + | DDX11L1 |
| ... | ... | ... | ... | ... | ... |
| 1 | exon | 1173055 | 1174055 | - | TTLL10-AS1 |
| 1 | exon | 1174055 | 1175055 | - | TTLL10-AS1 |
| 1 | exon | 1175055 | 1176055 | - | TTLL10-AS1 |
| 1 | exon | 1176055 | 1176396 | - | TTLL10-AS1 |
+--------------+--------------+-----------+-----------+--------------+-------------+
Stranded PyRanges object has 7,516 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
from pyranges.methods.windows import _windows
if strand is None:
strand = self.stranded
kwargs = {
"strand": strand,
"sparse": {"self": False},
"window_size": window_size,
}
df = pyrange_apply_single(_windows, self, **kwargs)
return PyRanges(df)
|
Return overlapping genomic windows.
Windows of length `window_size` are returned.
Parameters
----------
window_size : int
Length of the windows.
strand : bool, default None, i.e. auto
Whether to do operations on chromosome/strand pairs or chromosomes. If None, will use
chromosome/strand pairs if the PyRanges is stranded.
nb_cpu: int, default 1
How many cpus to use. Can at most use 1 per chromosome or chromosome/strand tuple.
Will only lead to speedups on large datasets.
**kwargs
Additional keyword arguments to pass as keyword arguments to `f`
Returns
-------
PyRanges
Tiled PyRanges.
See also
--------
pyranges.PyRanges.tile : divide intervals into adjacent tiles.
Examples
--------
>>> import pyranges as pr
>>> gr = pr.from_dict({"Chromosome": [1], "Start": [895], "End": [1259]})
>>> gr
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| 1 | 895 | 1259 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 1 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr.window(200)
+--------------+-----------+-----------+
| Chromosome | Start | End |
| (category) | (int64) | (int64) |
|--------------+-----------+-----------|
| 1 | 895 | 1095 |
| 1 | 1095 | 1259 |
+--------------+-----------+-----------+
Unstranded PyRanges object has 2 rows and 3 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome.
>>> gr2 = pr.data.ensembl_gtf()[["Feature", "gene_name"]]
>>> gr2
+--------------+--------------+-----------+-----------+--------------+-------------+
| Chromosome | Feature | Start | End | Strand | gene_name |
| (category) | (category) | (int64) | (int64) | (category) | (object) |
|--------------+--------------+-----------+-----------+--------------+-------------|
| 1 | gene | 11868 | 14409 | + | DDX11L1 |
| 1 | transcript | 11868 | 14409 | + | DDX11L1 |
| 1 | exon | 11868 | 12227 | + | DDX11L1 |
| 1 | exon | 12612 | 12721 | + | DDX11L1 |
| ... | ... | ... | ... | ... | ... |
| 1 | gene | 1173055 | 1179555 | - | TTLL10-AS1 |
| 1 | transcript | 1173055 | 1179555 | - | TTLL10-AS1 |
| 1 | exon | 1179364 | 1179555 | - | TTLL10-AS1 |
| 1 | exon | 1173055 | 1176396 | - | TTLL10-AS1 |
+--------------+--------------+-----------+-----------+--------------+-------------+
Stranded PyRanges object has 2,446 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
>>> gr2 = pr.data.ensembl_gtf()[["Feature", "gene_name"]]
>>> gr2.window(1000)
+--------------+--------------+-----------+-----------+--------------+-------------+
| Chromosome | Feature | Start | End | Strand | gene_name |
| (category) | (category) | (int64) | (int64) | (category) | (object) |
|--------------+--------------+-----------+-----------+--------------+-------------|
| 1 | gene | 11868 | 12868 | + | DDX11L1 |
| 1 | gene | 12868 | 13868 | + | DDX11L1 |
| 1 | gene | 13868 | 14409 | + | DDX11L1 |
| 1 | transcript | 11868 | 12868 | + | DDX11L1 |
| ... | ... | ... | ... | ... | ... |
| 1 | exon | 1173055 | 1174055 | - | TTLL10-AS1 |
| 1 | exon | 1174055 | 1175055 | - | TTLL10-AS1 |
| 1 | exon | 1175055 | 1176055 | - | TTLL10-AS1 |
| 1 | exon | 1176055 | 1176396 | - | TTLL10-AS1 |
+--------------+--------------+-----------+-----------+--------------+-------------+
Stranded PyRanges object has 7,516 rows and 6 columns from 1 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
window
|
python
|
pyranges/pyranges
|
pyranges/pyranges_main.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/pyranges_main.py
|
MIT
|
def rename_core_attrs(df, ftype, rename_attr=False):
"""Deduplicate columns from GTF attributes that share names
with the default 8 columns by appending "_attr" to each name if
rename_attr==True. Otherwise throw an error informing user of
formatting issues.
Parameters
----------
df : pandas DataFrame
DataFrame from read_gtf
ftype : str
{'gtf' or 'gff3'}
rename_attr : bool, default False
Whether to rename (potential) attributes with reserved column names
with the suffix '_attr' or to just raise an error (default)
Returns
-------
df : pandas DataFrame
DataFrame with deduplicated column names
"""
if ftype == "gtf":
core_cols = _ordered_gtf_columns
elif ftype == "gff3":
core_cols = _ordered_gff3_columns
dupe_core_cols = list(set(df.columns) & set(core_cols))
# if duplicate columns were found
if len(dupe_core_cols) > 0:
print(f"Found attributes with reserved names: {dupe_core_cols}.")
if not rename_attr:
raise ValueError
else:
print("Renaming attributes with suffix '_attr'")
dupe_core_dict = dict()
for c in dupe_core_cols:
dupe_core_dict[c] = f"{c}_attr"
df.rename(dupe_core_dict, axis=1, inplace=True)
return df
|
Deduplicate columns from GTF attributes that share names
with the default 8 columns by appending "_attr" to each name if
rename_attr==True. Otherwise throw an error informing user of
formatting issues.
Parameters
----------
df : pandas DataFrame
DataFrame from read_gtf
ftype : str
{'gtf' or 'gff3'}
rename_attr : bool, default False
Whether to rename (potential) attributes with reserved column names
with the suffix '_attr' or to just raise an error (default)
Returns
-------
df : pandas DataFrame
DataFrame with deduplicated column names
|
rename_core_attrs
|
python
|
pyranges/pyranges
|
pyranges/readers.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/readers.py
|
MIT
|
def read_bam(f, sparse=True, as_df=False, mapq=0, required_flag=0, filter_flag=1540):
"""Return bam file as PyRanges.
Parameters
----------
f : str
Path to bam file
sparse : bool, default True
Whether to return only.
as_df : bool, default False
Whether to return as pandas DataFrame instead of PyRanges.
mapq : int, default 0
Minimum mapping quality score.
required_flag : int, default 0
Flags which must be present for the interval to be read.
filter_flag : int, default 1540
Ignore reads with these flags. Default 1540, which means that either
the read is unmapped, the read failed vendor or platfrom quality
checks, or the read is a PCR or optical duplicate.
Notes
-----
This functionality requires the library `bamread`. It can be installed with
`pip install bamread` or `conda install -c bioconda bamread`.
Examples
--------
>>> path = pr.get_example_path("control.bam")
>>> pr.read_bam(path).sort()
+--------------+-----------+-----------+--------------+------------+
| Chromosome | Start | End | Strand | Flag |
| (category) | (int64) | (int64) | (category) | (uint16) |
|--------------+-----------+-----------+--------------+------------|
| chr1 | 1041102 | 1041127 | + | 0 |
| chr1 | 2129359 | 2129384 | + | 0 |
| chr1 | 2239108 | 2239133 | + | 0 |
| chr1 | 2318805 | 2318830 | + | 0 |
| ... | ... | ... | ... | ... |
| chrY | 10632456 | 10632481 | - | 16 |
| chrY | 11918814 | 11918839 | - | 16 |
| chrY | 11936866 | 11936891 | - | 16 |
| chrY | 57402214 | 57402239 | - | 16 |
+--------------+-----------+-----------+--------------+------------+
Stranded PyRanges object has 10,000 rows and 5 columns from 25 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
"""
try:
import bamread # type: ignore
except ImportError:
print(
"bamread must be installed to read bam. Use `conda install -c bioconda bamread` or `pip install bamread` to install it."
)
sys.exit(1)
if bamread.__version__ in [
"0.0.1",
"0.0.2",
"0.0.3",
"0.0.4",
"0.0.5",
"0.0.6",
"0.0.7",
"0.0.8",
"0.0.9",
]:
print(
"bamread not recent enough. Must be 0.0.10 or higher. Use `conda install -c bioconda 'bamread>=0.0.10'` or `pip install bamread>=0.0.10` to install it."
)
sys.exit(1)
if sparse:
df = bamread.read_bam(f, mapq, required_flag, filter_flag)
else:
try:
df = bamread.read_bam_full(f, mapq, required_flag, filter_flag)
except AttributeError:
print("bamread version 0.0.6 or higher is required to read bam non-sparsely.")
if as_df:
return df
else:
return PyRanges(df)
# return bamread.read_bam(f, mapq, required_flag, filter_flag)
|
Return bam file as PyRanges.
Parameters
----------
f : str
Path to bam file
sparse : bool, default True
Whether to return only.
as_df : bool, default False
Whether to return as pandas DataFrame instead of PyRanges.
mapq : int, default 0
Minimum mapping quality score.
required_flag : int, default 0
Flags which must be present for the interval to be read.
filter_flag : int, default 1540
Ignore reads with these flags. Default 1540, which means that either
the read is unmapped, the read failed vendor or platfrom quality
checks, or the read is a PCR or optical duplicate.
Notes
-----
This functionality requires the library `bamread`. It can be installed with
`pip install bamread` or `conda install -c bioconda bamread`.
Examples
--------
>>> path = pr.get_example_path("control.bam")
>>> pr.read_bam(path).sort()
+--------------+-----------+-----------+--------------+------------+
| Chromosome | Start | End | Strand | Flag |
| (category) | (int64) | (int64) | (category) | (uint16) |
|--------------+-----------+-----------+--------------+------------|
| chr1 | 1041102 | 1041127 | + | 0 |
| chr1 | 2129359 | 2129384 | + | 0 |
| chr1 | 2239108 | 2239133 | + | 0 |
| chr1 | 2318805 | 2318830 | + | 0 |
| ... | ... | ... | ... | ... |
| chrY | 10632456 | 10632481 | - | 16 |
| chrY | 11918814 | 11918839 | - | 16 |
| chrY | 11936866 | 11936891 | - | 16 |
| chrY | 57402214 | 57402239 | - | 16 |
+--------------+-----------+-----------+--------------+------------+
Stranded PyRanges object has 10,000 rows and 5 columns from 25 chromosomes.
For printing, the PyRanges was sorted on Chromosome and Strand.
|
read_bam
|
python
|
pyranges/pyranges
|
pyranges/readers.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/readers.py
|
MIT
|
def read_gtf(
f,
full=True,
as_df=False,
nrows=None,
duplicate_attr=False,
rename_attr=False,
ignore_bad: bool = False,
):
"""Read files in the Gene Transfer Format.
Parameters
----------
f : str
Path to GTF file.
full : bool, default True
Whether to read and interpret the annotation column.
as_df : bool, default False
Whether to return as pandas DataFrame instead of PyRanges.
nrows : int, default None
Number of rows to read. Default None, i.e. all.
duplicate_attr : bool, default False
Whether to handle (potential) duplicate attributes or just keep last one.
rename_attr : bool, default False
Whether to rename (potential) attributes with reserved column names
with the suffix '_attr' or to just raise an error (default)
ignore_bad : bool, default False
Whether to ignore bad lines or raise an error.
Note
----
The GTF format encodes both Start and End as 1-based included.
PyRanges (and also the DF returned by this function, if as_df=True), instead
encodes intervals as 0-based, Start included and End excluded.
See Also
--------
pyranges.read_gff3 : read files in the General Feature Format
Examples
--------
>>> path = pr.get_example_path("ensembl.gtf")
>>> gr = pr.read_gtf(path)
>>> # +--------------+------------+--------------+-----------+-----------+------------+--------------+------------+-----------------+----------------+-------+
>>> # | Chromosome | Source | Feature | Start | End | Score | Strand | Frame | gene_id | gene_version | +18 |
>>> # | (category) | (object) | (category) | (int64) | (int64) | (object) | (category) | (object) | (object) | (object) | ... |
>>> # |--------------+------------+--------------+-----------+-----------+------------+--------------+------------+-----------------+----------------+-------|
>>> # | 1 | havana | gene | 11868 | 14409 | . | + | . | ENSG00000223972 | 5 | ... |
>>> # | 1 | havana | transcript | 11868 | 14409 | . | + | . | ENSG00000223972 | 5 | ... |
>>> # | 1 | havana | exon | 11868 | 12227 | . | + | . | ENSG00000223972 | 5 | ... |
>>> # | 1 | havana | exon | 12612 | 12721 | . | + | . | ENSG00000223972 | 5 | ... |
>>> # | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... |
>>> # | 1 | ensembl | transcript | 120724 | 133723 | . | - | . | ENSG00000238009 | 6 | ... |
>>> # | 1 | ensembl | exon | 133373 | 133723 | . | - | . | ENSG00000238009 | 6 | ... |
>>> # | 1 | ensembl | exon | 129054 | 129223 | . | - | . | ENSG00000238009 | 6 | ... |
>>> # | 1 | ensembl | exon | 120873 | 120932 | . | - | . | ENSG00000238009 | 6 | ... |
>>> # +--------------+------------+--------------+-----------+-----------+------------+--------------+------------+-----------------+----------------+-------+
>>> # Stranded PyRanges object has 95 rows and 28 columns from 1 chromosomes.
>>> # For printing, the PyRanges was sorted on Chromosome and Strand.
>>> # 18 hidden columns: gene_name, gene_source, gene_biotype, transcript_id, transcript_version, transcript_name, transcript_source, transcript_biotype, tag, transcript_support_level, ... (+ 8 more.)
"""
_skiprows = skiprows(f)
if full:
gr = read_gtf_full(
f,
as_df,
nrows,
_skiprows,
duplicate_attr,
rename_attr,
ignore_bad=ignore_bad,
)
else:
gr = read_gtf_restricted(f, _skiprows, as_df=False, nrows=None)
return gr
|
Read files in the Gene Transfer Format.
Parameters
----------
f : str
Path to GTF file.
full : bool, default True
Whether to read and interpret the annotation column.
as_df : bool, default False
Whether to return as pandas DataFrame instead of PyRanges.
nrows : int, default None
Number of rows to read. Default None, i.e. all.
duplicate_attr : bool, default False
Whether to handle (potential) duplicate attributes or just keep last one.
rename_attr : bool, default False
Whether to rename (potential) attributes with reserved column names
with the suffix '_attr' or to just raise an error (default)
ignore_bad : bool, default False
Whether to ignore bad lines or raise an error.
Note
----
The GTF format encodes both Start and End as 1-based included.
PyRanges (and also the DF returned by this function, if as_df=True), instead
encodes intervals as 0-based, Start included and End excluded.
See Also
--------
pyranges.read_gff3 : read files in the General Feature Format
Examples
--------
>>> path = pr.get_example_path("ensembl.gtf")
>>> gr = pr.read_gtf(path)
>>> # +--------------+------------+--------------+-----------+-----------+------------+--------------+------------+-----------------+----------------+-------+
>>> # | Chromosome | Source | Feature | Start | End | Score | Strand | Frame | gene_id | gene_version | +18 |
>>> # | (category) | (object) | (category) | (int64) | (int64) | (object) | (category) | (object) | (object) | (object) | ... |
>>> # |--------------+------------+--------------+-----------+-----------+------------+--------------+------------+-----------------+----------------+-------|
>>> # | 1 | havana | gene | 11868 | 14409 | . | + | . | ENSG00000223972 | 5 | ... |
>>> # | 1 | havana | transcript | 11868 | 14409 | . | + | . | ENSG00000223972 | 5 | ... |
>>> # | 1 | havana | exon | 11868 | 12227 | . | + | . | ENSG00000223972 | 5 | ... |
>>> # | 1 | havana | exon | 12612 | 12721 | . | + | . | ENSG00000223972 | 5 | ... |
>>> # | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... |
>>> # | 1 | ensembl | transcript | 120724 | 133723 | . | - | . | ENSG00000238009 | 6 | ... |
>>> # | 1 | ensembl | exon | 133373 | 133723 | . | - | . | ENSG00000238009 | 6 | ... |
>>> # | 1 | ensembl | exon | 129054 | 129223 | . | - | . | ENSG00000238009 | 6 | ... |
>>> # | 1 | ensembl | exon | 120873 | 120932 | . | - | . | ENSG00000238009 | 6 | ... |
>>> # +--------------+------------+--------------+-----------+-----------+------------+--------------+------------+-----------------+----------------+-------+
>>> # Stranded PyRanges object has 95 rows and 28 columns from 1 chromosomes.
>>> # For printing, the PyRanges was sorted on Chromosome and Strand.
>>> # 18 hidden columns: gene_name, gene_source, gene_biotype, transcript_id, transcript_version, transcript_name, transcript_source, transcript_biotype, tag, transcript_support_level, ... (+ 8 more.)
|
read_gtf
|
python
|
pyranges/pyranges
|
pyranges/readers.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/readers.py
|
MIT
|
def read_gtf_restricted(f, skiprows, as_df=False, nrows=None):
"""seqname - name of the chromosome or scaffold; chromosome names can be given with or without the 'chr' prefix. Important note: the seqname must be one used within Ensembl, i.e. a standard chromosome name or an Ensembl identifier such as a scaffold ID, without any additional content such as species or assembly. See the example GFF output below.
# source - name of the program that generated this feature, or the data source (database or project name)
feature - feature type name, e.g. Gene, Variation, Similarity
start - Start position of the feature, with sequence numbering starting at 1.
end - End position of the feature, with sequence numbering starting at 1.
score - A floating point value.
strand - defined as + (forward) or - (reverse).
# frame - One of '0', '1' or '2'. '0' indicates that the first base of the feature is the first base of a codon, '1' that the second base is the first base of a codon, and so on..
attribute - A semicolon-separated list of tag-value pairs, providing additional information about each feature.
"""
dtypes = {"Chromosome": "category", "Feature": "category", "Strand": "category"}
df_iter = pd.read_csv(
f,
sep="\t",
comment="#",
usecols=[0, 2, 3, 4, 5, 6, 8],
header=None,
names="Chromosome Feature Start End Score Strand Attribute".split(),
dtype=dtypes,
chunksize=int(1e5),
skiprows=skiprows,
nrows=nrows,
)
dfs = []
for df in df_iter:
if sum(df.Score == ".") == len(df):
cols_to_concat = "Chromosome Start End Strand Feature".split()
else:
cols_to_concat = "Chromosome Start End Strand Feature Score".split()
extract = _fetch_gene_transcript_exon_id(df.Attribute)
extract.columns = "gene_id transcript_id exon_number exon_id".split()
extract.exon_number = extract.exon_number.astype(float)
extract.set_index(df.index, inplace=True)
df = pd.concat([df[cols_to_concat], extract], axis=1, sort=False)
dfs.append(df)
df = pd.concat(dfs, sort=False)
df.loc[:, "Start"] = df.Start - 1
if not as_df:
return PyRanges(df)
else:
return df
|
seqname - name of the chromosome or scaffold; chromosome names can be given with or without the 'chr' prefix. Important note: the seqname must be one used within Ensembl, i.e. a standard chromosome name or an Ensembl identifier such as a scaffold ID, without any additional content such as species or assembly. See the example GFF output below.
# source - name of the program that generated this feature, or the data source (database or project name)
feature - feature type name, e.g. Gene, Variation, Similarity
start - Start position of the feature, with sequence numbering starting at 1.
end - End position of the feature, with sequence numbering starting at 1.
score - A floating point value.
strand - defined as + (forward) or - (reverse).
# frame - One of '0', '1' or '2'. '0' indicates that the first base of the feature is the first base of a codon, '1' that the second base is the first base of a codon, and so on..
attribute - A semicolon-separated list of tag-value pairs, providing additional information about each feature.
|
read_gtf_restricted
|
python
|
pyranges/pyranges
|
pyranges/readers.py
|
https://github.com/pyranges/pyranges/blob/master/pyranges/readers.py
|
MIT
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.