poreflow 0.2.4__tar.gz → 0.3.3__tar.gz

poreflow-0.3.3/CMakeLists.txt

@@ -0,0 +1,31 @@
+cmake_minimum_required(VERSION 3.15)
+project(poreflow_changepoint)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Find Python and its associated components, natively including NumPy
+find_package(Python 3.11 COMPONENTS Interpreter Development.Module NumPy REQUIRED)
+
+# Use FetchContent to get Eigen
+include(FetchContent)
+
+FetchContent_Declare(
+  Eigen3
+  GIT_REPOSITORY https://gitlab.com/libeigen/eigen.git
+  GIT_TAG 5.0.1
+  GIT_SHALLOW TRUE
+)
+FetchContent_MakeAvailable(Eigen3)
+
+# Define the extension module
+python_add_library(_changepoint MODULE src/poreflow/steps/_changepoint.cpp)
+
+# Include directories, utilizing the variable populated by FindPython
+target_include_directories(_changepoint PRIVATE
+    ${Python_NumPy_INCLUDE_DIRS}
+    ${Eigen3_SOURCE_DIR}
+)
+
+# Install location
+install(TARGETS _changepoint DESTINATION poreflow/steps)

{poreflow-0.2.4 → poreflow-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: poreflow
-Version: 0.2.4
+Version: 0.3.3
 Summary: Python module for processing nanopore sequencing
 Keywords: nanopore,peptide,bioinformatics
 Author-Email: Xiuqi Chen <X.Chen-13@tudelft.nl>, Thijn Hoekstra <thijnhoekstra@gmail.com>
@@ -49,6 +49,9 @@ Description-Content-Type: text/markdown
 # PoreFlow
 > *Nanopore data analysis tools*
 
+[![pipeline status](https://gitlab.tudelft.nl/xiuqichen/poreFlow/badges/main/pipeline.svg)](https://gitlab.tudelft.nl/xiuqichen/poreFlow/-/commits/main)
+[![Latest Release](https://gitlab.tudelft.nl/xiuqichen/poreFlow/-/badges/release.svg)](https://gitlab.tudelft.nl/xiuqichen/poreFlow/-/releases)
+
 PoreFlow is a fast, simple, and flexible set of tools for analysing raw nanopore sequencing data, 
 intended for use for research in the Cees Dekker lab (and beyond?). 
 

{poreflow-0.2.4 → poreflow-0.3.3}/README.md

@@ -1,6 +1,9 @@
 # PoreFlow
 > *Nanopore data analysis tools*
 
+[![pipeline status](https://gitlab.tudelft.nl/xiuqichen/poreFlow/badges/main/pipeline.svg)](https://gitlab.tudelft.nl/xiuqichen/poreFlow/-/commits/main)
+[![Latest Release](https://gitlab.tudelft.nl/xiuqichen/poreFlow/-/badges/release.svg)](https://gitlab.tudelft.nl/xiuqichen/poreFlow/-/releases)
+
 PoreFlow is a fast, simple, and flexible set of tools for analysing raw nanopore sequencing data, 
 intended for use for research in the Cees Dekker lab (and beyond?). 
 

{poreflow-0.2.4 → poreflow-0.3.3}/pyproject.toml

@@ -47,13 +47,13 @@ Repository = "https://gitlab.tudelft.nl/xiuqichen/poreFlow.git"
 Issues = "https://gitlab.tudelft.nl/xiuqichen/poreFlow/-/issues"
 
 [tool.scikit-build]
+metadata.version.provider = "scikit_build_core.metadata.setuptools_scm"
 wheel.packages = ["src/poreflow", "src/fast5_research"]
-sdist.include = ["src/*", "LICENSE.MD", "pyproject.toml", "CMakeLists.txt", "README.md"]
+sdist.include = ["src/*", "src/poreflow/_version.py", "LICENSE.MD", "pyproject.toml", "CMakeLists.txt", "README.md"]
 sdist.exclude = ["*"]
 
-[tool.scikit-build.metadata.version]
-provider = "scikit_build_core.metadata.regex"
-input = "src/poreflow/__init__.py"
+[tool.setuptools_scm]  # Section required
+write_to = "src/poreflow/_version.py"
 
 [dependency-groups]
 dev = [

{poreflow-0.2.4 → poreflow-0.3.3}/src/fast5_research/util.py

@@ -7,16 +7,16 @@ import sys
 import numpy as np
 import numpy.lib.recfunctions as nprf
 
+
 def descale(
-        x: np.ndarray,
-        meta: dict,
-        dtype: np.dtype = np.int16,
+    x: np.ndarray,
+    meta: dict,
+    dtype: np.dtype = np.int16,
 ) -> np.ndarray[np.int16]:
     """Scale float data down to int data"""
     return (x * meta["digitisation"] / meta["range"] - meta["offset"]).astype(dtype)
 
 
-
 def qstring_to_phred(quality):
     """Compute standard phred scores from a quality string."""
     qscores = [ord(q) - 33 for q in quality]
@@ -545,7 +545,7 @@ def med_mad(data, factor=None, axis=None, keepdims=False):
     :param data: A :class:`ndarray` object
     :param factor: Factor to scale MAD by. Default (None) is to be consistent
         with the standard deviation of a normal distribution
-        (i.e. mad( N(0,\sigma^2) ) = \sigma).
+        (i.e. mad( N(0,\\sigma^2) ) = \\sigma).
     :param axis: For multidimensional arrays, which axis to calculate over
     :param keepdims: If True, axis is kept as dimension of length 1
 
@@ -573,7 +573,7 @@ def mad(data, factor=None, axis=None, keepdims=False):
     :param data: A :class:`ndarray` object
     :param factor: Factor to scale MAD by. Default (None) is to be consistent
         with the standard deviation of a normal distribution
-        (i.e. mad( N(0,\sigma^2) ) = \sigma).
+        (i.e. mad( N(0,\\sigma^2) ) = \\sigma).
     :param axis: For multidimensional arrays, which axis to calculate the median over.
     :param keepdims: If True, axis is kept as dimension of length 1
 

{poreflow-0.2.4 → poreflow-0.3.3}/src/poreflow/__init__.py

@@ -15,18 +15,20 @@ from poreflow.io.devices import ONT, UTUBE
 from poreflow import constants
 from poreflow.constants import *
 
+from poreflow import _version
+
+__version__ = _version.__version__
+
 submodules = [
-    "classification",
-    "fast_5_research",
-    "feature_extraction",
-    "io",
-    "preprocessing",
+    "dashboards"
     "events",
-    "base",
-    "utils",
-    "widgets",
-    "plots",
+    "io",
+    "steps",
+    "structures",
+    "dataset",
     "parallel",
+    "plots",
+    "utils",
 ]
 
 __all__ = (
@@ -44,9 +46,6 @@ __all__ = (
     + constants.__all__
 )
 
-__version__ = "0.2.4"
-
-
 def __dir__():
     return __all__
 

poreflow-0.3.3/src/poreflow/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.3.3'
+__version_tuple__ = version_tuple = (0, 3, 3)
+
+__commit_id__ = commit_id = 'g5a625d68c'

poreflow-0.3.3/src/poreflow/events/__init__.py

@@ -0,0 +1,20 @@
+import importlib as _importlib
+
+submodules = [
+    "detection",
+    "open_state",
+    "voltage_state",
+    "selection",
+]
+
+__all__ = submodules
+
+
+def __getattr__(name):
+    if name in submodules:
+        return _importlib.import_module(f"poreflow.events.{name}")
+    else:
+        try:
+            return globals()[name]
+        except KeyError:
+            raise AttributeError(f"Module 'poreflow.events' has no attribute '{name}'")

poreflow-0.2.4/src/poreflow/preprocessing/eventdetection.py → poreflow-0.3.3/src/poreflow/events/detection.py

@@ -8,7 +8,7 @@ import numpy as np
 import pandas as pd
 
 import poreflow as pf
-from poreflow.preprocessing import openstate, voltagestate
+from poreflow.events import open_state, voltage_state
 
 DEFAULT_DEGREE = 1
 
@@ -18,29 +18,29 @@ class EventDetectionFailure(Exception):
 
 
 def find_events(
-        raw: pd.DataFrame,
-        open_state_range: tuple[float, float] = (200, 300),
-        voltage_range: tuple[float, float] = (175, 185),
-        closing_iterations: int | bool = 10,
-        boundary_trim: int = 5,
-        n_components: int = 3,
-        degree: int = DEFAULT_DEGREE,
-        min_frac_os: float = 0.01
+    raw: pd.DataFrame,
+    open_state_range: tuple[float, float] = (200, 300),
+    voltage_range: tuple[float, float] = (175, 185),
+    closing_iterations: int | bool = 10,
+    boundary_trim: int = 5,
+    n_components: int = 3,
+    degree: int = DEFAULT_DEGREE,
+    min_frac_os: float = 0.01,
 ) -> pf.EventsDataFrame | None:
-    component = openstate.find_open_state(raw, open_state_range, n_components)
+    component = open_state.find_open_state(raw, open_state_range, n_components)
 
     # "Bad state" still only open state
-    bad_state = openstate.get_open_state_mask(raw, component)
+    bad_state = open_state.get_open_state_mask(raw, component)
 
     if bad_state.sum() / len(raw) < min_frac_os:
         return None
 
-    poly = openstate.get_open_state_fit(raw, bad_state, degree)
+    poly = open_state.get_open_state_fit(raw, bad_state, degree)
     raw.ios = poly
 
     # Boolean AND: want to include all samples either in bad voltage or
     # in an open state
-    bad_state = bad_state | voltagestate.get_voltage_state_mask(raw, voltage_range)
+    bad_state = bad_state | voltage_state.get_voltage_state_mask(raw, voltage_range)
     bad_state = bad_state.to_numpy(dtype=bool)
 
     # Do binary closing to clean up mask
@@ -62,7 +62,7 @@ def find_events(
     df.trim_events(size=boundary_trim, recalculate_times=False)
     df.clip_events(lower=0, upper=len(raw))  # Times are recalculated here
 
-    add_local_openstate(df, poly)
+    add_local_open_state(df, poly)
 
     df[pf.CHANNEL_COL] = raw.channel
     df[pf.QUALITY_COL] = 0.0
@@ -90,7 +90,7 @@ def get_event_indices(bad_state: np.ndarray[np.bool]):
     return start_indices, end_indices
 
 
-def add_local_openstate(df: pd.DataFrame, poly: np.polynomial.Polynomial) -> None:
+def add_local_open_state(df: pd.DataFrame, poly: np.polynomial.Polynomial) -> None:
     start_ios = poly(df[pf.START_TIME_COL])
     end_ios = poly(df[pf.END_TIME_COL])
 

poreflow-0.2.4/src/poreflow/feature_selection/eventfiltering.py → poreflow-0.3.3/src/poreflow/events/selection.py

@@ -4,6 +4,46 @@ import pandas as pd
 
 import poreflow as pf
 
+from poreflow.steps import metrics
+
+
+def get_step_finding_stats(f: pf.File) -> pf.EventsDataFrame:
+    if not f.has_events:
+        raise RuntimeError("File must have events. Please run event detection first.")
+
+    if not f.has_events:
+        raise RuntimeError("File must have steps. Please run step detection first.")
+
+    steps = f.get_steps()
+    events = f.get_events()
+
+    events["std_of_step_means"] = get_std_of_step_means(steps)
+    events["n_steps"] = get_n_steps(steps)
+
+    events[pf.STEP_RATE_COL] = events["n_steps"] / events[pf.DURATION_COL]
+
+    events["binned_entropy_of_means"] = get_binned_entropies(events, steps)
+
+    return events
+
+
+def get_binned_entropies(
+    events: pf.EventsDataFrame, steps: pf.StepsDataFrame
+) -> pd.Series:
+    s = pd.Series(index=events.index, dtype=float)
+    for j, mean in steps.groupby(pf.EVENT_COL)[pf.MEAN_COL]:
+        s[j] = metrics.binned_entropy(mean)
+    return s
+
+
+def get_n_steps(steps: pf.StepsDataFrame) -> pd.Series:
+    return steps[pf.EVENT_COL].value_counts()
+
+
+def get_std_of_step_means(steps: pf.StepsDataFrame) -> pd.Series:
+    return steps.groupby(pf.EVENT_COL)[pf.MEAN_COL].std()
+
+
 def filter_from_config(events: pf.EventsDataFrame, conditions: dict) -> pd.DataFrame:
     """Filter using a dictionary of conditions
 
@@ -31,7 +71,9 @@ def filter_from_config(events: pf.EventsDataFrame, conditions: dict) -> pd.DataF
     """
     n_conditions = len(conditions)
 
-    targets = pd.DataFrame(index=range(n_conditions), columns=["col", "comparison", "value"], dtype=object)
+    targets = pd.DataFrame(
+        index=range(n_conditions), columns=["col", "comparison", "value"], dtype=object
+    )
     for j, (condition, value) in enumerate(conditions.items()):
         results = re.findall(r"(min|max)_(\w+)", condition)
 
@@ -39,12 +81,14 @@ def filter_from_config(events: pf.EventsDataFrame, conditions: dict) -> pd.DataF
             raise KeyError(
                 f'Condition "{condition}" could not be interpreted. '
                 'Please format as "min_[col]" or "max_[col]" in dict/TOML, '
-                'where [col] is a column available in the event dataframe.'
+                "where [col] is a column available in the event dataframe."
             )
         prefix, col = results[0]
 
         if col not in events.columns:
-            raise KeyError(f'Column {col} specified in condition "{condition}" not present in EventsDataFrame')
+            raise KeyError(
+                f'Column {col} specified in condition "{condition}" not present in EventsDataFrame'
+            )
 
         if prefix == "min":
             comparison = ">"
@@ -69,4 +113,4 @@ def filter_from_config(events: pf.EventsDataFrame, conditions: dict) -> pd.DataF
             truth_table.iloc[:, tup.Index] = events[tup.col] > tup.value
 
     truth_table["all"] = truth_table.all(axis=1)
-    return truth_table
+    return truth_table

{poreflow-0.2.4 → poreflow-0.3.3}/src/poreflow/io/ont.py

@@ -24,7 +24,8 @@ import scipy.signal
 from fast5_research.fast5_bulk import BulkFast5
 
 import poreflow as pf
-import poreflow.feature_extraction.changepoint
+from poreflow.events import detection
+from poreflow.steps import changepoint
 from poreflow.parallel import mapper
 
 META_DURATION_ATTR_NAME = "duration_samples"
@@ -108,6 +109,8 @@ class File(BulkFast5):
             g_meta.attrs["poreflow_version"] = pf.__version__
             g_meta.attrs["python_version"] = platform.python_version()
 
+        self._name = None
+
     @property
     def poreflow_group(self):
         return self[pf.POREFLOW_GROUP]
@@ -116,6 +119,18 @@ class File(BulkFast5):
     def has_poreflow_data(self):
         return pf.POREFLOW_GROUP in self
 
+    @property
+    def name(self) -> str:
+        """Pretty name, defaults to filename."""
+        return (
+            self._name if self._name is not None else pathlib.Path(self.filename).stem
+        )
+
+    @name.setter
+    def name(self, value: str):
+        """Set a pretty name"""
+        self._name = value
+
     @property
     def device(self):
         if self.tracking_meta["device_id"] == pf.UTUBE:
@@ -123,14 +138,30 @@ class File(BulkFast5):
         else:
             return pf.ONT
 
+    @property
+    def n_events(self) -> int:
+        return len(self.poreflow_group[pf.EVENTS_DATASET])
+
+    @property
+    def n_steps(self) -> int:
+        return len(self.poreflow_group[pf.STEPS_DATASET])
+
     def get_channels(self):
-        """Tries getting channels even when in write mode."""
+        """Tries getting channels even when in write mode.
+
+        Returns:
+            list: List of channel numbers in file. Starts from 0.
+
+        Note:
+            ONT stores channels in Fast5 files starting from 1. Channels
+            in poreFlow are indexed from 0. So 0 --> Channel 1, etc.
+        """
         data = self[self.__intermediate_data__]
-        return sorted([int(name.strip("Channel_")) for name in data.keys()])
+        return sorted([int(name.strip("Channel_")) - 1 for name in data.keys()])
 
     def _get_channel_data(
         self,
-        channel: int = 1,
+        channel: int = 0,
         times: typing.Optional[typing.Tuple[float, float]] = None,
         index: typing.Optional[typing.Tuple[int, int]] = None,
         downsample: typing.Optional[float] = None,
@@ -164,7 +195,8 @@ class File(BulkFast5):
         elif index:
             raw_indices = index
 
-        out = [super().get_raw(channel, times, raw_indices)]
+        # ONT stores channels starting from 1
+        out = [super().get_raw(channel + 1, times, raw_indices)]
 
         if read_voltage:
             out.append(super().get_voltage(times, raw_indices))
@@ -192,7 +224,7 @@ class File(BulkFast5):
 
     def get_data(
         self,
-        channel: int = 1,
+        channel: int = 0,
         times: typing.Optional[typing.Tuple[float, float]] = None,
         index: typing.Optional[typing.Tuple[int, int]] = None,
         downsample: typing.Optional[float] = None,
@@ -224,12 +256,12 @@ class File(BulkFast5):
             {pf.CURRENT_FIELD_NAME: current_data},
             sfreq=sfreq,
             channel=channel,
-            name=self.filename,
+            name=self.name,
         )
 
     def get_raw(
         self,
-        channel: int = 1,
+        channel: int = 0,
         times: tuple[float, float] = None,
         index: tuple[int, int] = None,
         downsample: float = None,
@@ -258,13 +290,11 @@ class File(BulkFast5):
             channel, times, index, downsample
         )
 
-        filename = pathlib.Path(self.filename).stem
-
         return pf.RawDataFrame(
             {pf.CURRENT_FIELD_NAME: current_data, pf.VOLTAGE_FIELD_NAME: voltage_data},
             sfreq=sfreq,
             channel=channel,
-            name=f"Channel {channel} of {filename}",
+            name=f"Channel {channel} of {self.name}",
             ios=self.get_ios(channel),
         )
 
@@ -291,7 +321,7 @@ class File(BulkFast5):
                 start * sfreq / self.sfreq
             ),  # Scale start_idx if downsample was used
             ios=row[pf.IOS_COL],
-            name=f"Event {item} in channel {channel} of {self.filename}",
+            name=f"Event {item} in channel {channel} of {self.name}",
             quality=row[pf.QUALITY_COL],
             label=row[pf.LABEL_COL],
         )
@@ -452,7 +482,7 @@ class File(BulkFast5):
             data=rec,
         )
 
-    def set_ios(self, p: np.polynomial.Polynomial, channel: int = 1):
+    def set_ios(self, p: np.polynomial.Polynomial, channel: int = 0):
 
         if pf.IOS_FIT_DATASET not in self.poreflow_group:
             self._create_ios_fit_dataset(p.degree())
@@ -476,7 +506,7 @@ class File(BulkFast5):
 
         return _remove_index(df)
 
-    def get_ios(self, channel: int = 1) -> np.polynomial.Polynomial | None:
+    def get_ios(self, channel: int = 0) -> np.polynomial.Polynomial | None:
 
         if not self.has_poreflow_data or (
             pf.IOS_FIT_DATASET not in self.poreflow_group
@@ -528,13 +558,7 @@ class File(BulkFast5):
 
         return results
 
-    def find_events(
-            self,
-            processes=None,
-            verbose=0,
-            channels: list = None,
-            **kwargs
-    ):
+    def find_events(self, processes=None, verbose=0, channels: list = None, **kwargs):
         """
         Find events in the file using parallel processing.
 
@@ -548,25 +572,24 @@ class File(BulkFast5):
             Closes file, does processing, and then opens it again by calling
             __init__.
         """
-        from poreflow.preprocessing import eventdetection
 
         if self.mode != "r+":
             raise IOError("Must set mode to read and write (r+)")
 
         self.set_events(None)
-        degree = kwargs.get("degree", eventdetection.DEFAULT_DEGREE)
+        degree = kwargs.get("degree", detection.DEFAULT_DEGREE)
         self._create_ios_fit_dataset(degree)
 
         if channels is None:
             channels = self.get_channels()
 
         results = self.map(
-            eventdetection.event_detection_worker,
+            detection.event_detection_worker,
             channels,
             processes=processes,
             verbose=verbose,
             callback=functools.partial(
-                eventdetection.save_events_to_file,
+                detection.save_events_to_file,
                 fname=self.filename,
                 verbose=verbose,
             ),
@@ -574,7 +597,11 @@ class File(BulkFast5):
         )
 
         if verbose > 0:
-            eventdetection.summarize_events(results)
+            detection.summarize_events(results)
+
+    def iter_events(self, **kwargs):
+        for j in range(self.n_events):
+            yield self.get_event(j, **kwargs)
 
     def find_steps(self, processes=None, verbose=0, events: list = None, **kwargs):
 
@@ -587,19 +614,19 @@ class File(BulkFast5):
             events = range(len(self.get_events()))
 
         results = self.map(
-            poreflow.feature_extraction.changepoint.step_finding_worker,
+            changepoint.step_finding_worker,
             events,
             processes=processes,
             verbose=verbose,
             callback=functools.partial(
-                poreflow.feature_extraction.changepoint.save_steps_to_file,
+                changepoint.save_steps_to_file,
                 fname=self.filename,
             ),
             **kwargs,
         )
 
         if verbose > 0:
-            poreflow.feature_extraction.changepoint.summarize_steps(results)
+            changepoint.summarize_steps(results)
 
     def filter_events(self, mask: pd.Series) -> None:
         """Remove events using a mask

{poreflow-0.2.4 → poreflow-0.3.3}/src/poreflow/parallel.py

@@ -3,16 +3,16 @@ import multiprocessing
 import os
 import threading
 import time
-from multiprocessing import Manager, Pool
+
 from multiprocessing.pool import Pool
+from multiprocessing import Manager
+
 
 import numpy as np
 import psutil
 
 from tqdm.auto import tqdm
 
-import poreflow as pf
-
 
 def imap_worker_wrapper(args):
     """Generic wrapper to unpack arguments for any function in imap"""
@@ -91,7 +91,7 @@ class MemoryMonitor:
             if proc.is_alive():
                 try:
                     memory += psutil.Process(proc.pid).memory_info().rss / 1024 / 1024
-                except:
+                except Exception:
                     pass
 
         self.pbar.set_description(

poreflow-0.3.3/src/poreflow/steps/__init__.py

@@ -0,0 +1,21 @@
+import importlib as _importlib
+
+submodules = [
+    "changepoint",
+    "cpic",
+    "metrics",
+    "predict",
+    "sequence",
+]
+
+__all__ = submodules
+
+
+def __getattr__(name):
+    if name in submodules:
+        return _importlib.import_module(f"poreflow.steps.{name}")
+    else:
+        try:
+            return globals()[name]
+        except KeyError:
+            raise AttributeError(f"Module 'poreflow.steps' has no attribute '{name}'")

poreflow-0.2.4/src/poreflow/classification/predictdna.py → poreflow-0.3.3/src/poreflow/steps/predict.py

@@ -4,13 +4,14 @@ from collections import deque
 from importlib import resources as impresources
 from itertools import islice
 
-import poreflow as pf
-from poreflow.classification import assets
-
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
 
+import poreflow as pf
+from poreflow.steps import assets
+
+
 inp_file = impresources.files(assets) / "DNA_6mer_prediction_model_cv.csv"
 
 DNA_MODEL = pd.read_csv(inp_file)
@@ -39,7 +40,7 @@ def predict(sequence, model: pd.DataFrame = None, k_mer_size=6, nan_policy="omit
     half-steps. Returns a signal from 3-prime end to 5-prime end.
 
     Args:
-        sequence (str): Sequence in 5-prime to 3-prime format.
+        sequence (str): Sequence in 5-prime to 3-prime format. Sequence may have lower case letters.
         model: Dataframe of DNA model
         k_mer_size: k-mer size. Defaults to 6.
         nan_policy: Whether to return NaN for the steps in the sequence that do not have a k-mer (at the beginning and
@@ -49,6 +50,7 @@ def predict(sequence, model: pd.DataFrame = None, k_mer_size=6, nan_policy="omit
         model = DNA_MODEL
 
     sequence = sequence[::-1]  # Reverse the string (3'->5')
+    sequence = sequence.upper()
     constriction_kmer_offset = -4
 
     sub_6mer = list(sliding_window(sequence, k_mer_size))