blixa 1.0.0__py3-none-any.whl

blixa-1.0.0.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: blixa
+Version: 1.0.0
+Summary: Blixa: A Domain-Specific Language for Biological Research
+Author: AHMED TARIG AHMED ABDALGALEEL
+Requires-Python: >=3.11
+License-File: LICENSE
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: biopython>=1.81
+Requires-Dist: scanpy>=1.9.3
+Requires-Dist: anndata>=0.9.1
+Requires-Dist: matplotlib>=3.7.1
+Requires-Dist: seaborn>=0.12.2
+Requires-Dist: scikit-learn>=1.2.2
+Requires-Dist: statsmodels>=0.14.0
+Requires-Dist: joblib>=1.3.0
+Requires-Dist: pytest>=7.4.0
+Requires-Dist: seqfold>=0.0.9
+Requires-Dist: gseapy>=1.1.0
+Dynamic: author
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

blixa-1.0.0.dist-info/RECORD

@@ -0,0 +1,37 @@
+blixa-1.0.0.dist-info/licenses/LICENSE,sha256=rXFI0zviRWn_V3xYbOfZWNFuia9hDQDkoiJ6JFFCd7E,1095
+core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+core/base.py,sha256=auGmp07Z6zFVQj-n6Fl7OoH1yBlRxQO7ZoXKj2eBO7Q,2473
+core/cell.py,sha256=jjM63wZLQeWn-YlVEqff0GrenvAwfHWVBDcR_9v01SI,6695
+core/dna.py,sha256=M29oRggrBqUbRHEeLUuBvqnRVyjPvFIlbqGeY1DHW08,8993
+core/experiment.py,sha256=8EkjScC1IaHUO6JXM-1VqNPwabhyiuae9SQRbgh6irA,8777
+core/functions.py,sha256=G-yvawANyyenX6C8Mh_C5DyAmSRytp8cU6LuJI9DV28,10204
+core/gene.py,sha256=IiX7vWvWCbhe_5uJXjjsIEPOLo7Ya8ITaqF5M9lQn_c,7438
+core/population.py,sha256=yXC0SRiSxaCK5Zog0_ucwTUxSwgkdehewUBtvpad2bA,19405
+core/protein.py,sha256=umNvwpfgppakCEIm7RGuY5rvA423lIOQmXpsY4SiCMM,9774
+core/result.py,sha256=MPH7VIihkQOmylU6fU5-wJerZ36jzF2WpB2efuW4yBw,12256
+core/rna.py,sha256=2IQo9iGhnqntPW3j__2wWBtO-O4w46aQGTbbUaal6_E,7820
+core/workflow.py,sha256=z7l9P47SmGNX3qRGzJmrmyGRxFOxpd_ELL-cliklilU,7479
+exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+exceptions/bio_errors.py,sha256=z9dnCLnhCw7GiFOXkNYB_-cSBS5YvsU5CUNjQHbovgY,663
+modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+modules/crispr.py,sha256=TWmUf9w2uvELArijmeDXc9erPwx9Q9Wi-SzNKQmFNEk,9224
+modules/epigenetics.py,sha256=0kUSMLgrPPn-rmQKvxTIcV5wbHS25Y3O_fgvtNnojmE,6360
+modules/genomics.py,sha256=DZmqb_CDimois46H3myJkB98rWFQc4F-bS5OhqP2zJ4,5657
+modules/integration.py,sha256=PVRMU7ox-fRXO7IHJOOB1zikZUgxHuUnp0JAp4Dy9qU,7838
+modules/pathways.py,sha256=EKWjzYseCdZWz4HRX1aDdgOcjZ2c0ngviMXBPhQ1VB4,6782
+modules/proteomics.py,sha256=qHvOIRwmO36YJ262Rm56LEm2sHiaZP8mnC5VVLZuZOg,5152
+modules/singlecell.py,sha256=sN0cO3y7dxksZgq95hFSwwvI9_SUPsdMLCLsIjlTAaU,6179
+modules/statistics.py,sha256=UVizaOMgtOqEGwRFhVA1ZMd0KxNsP2r6bFh6nGoques,5908
+modules/stemcell.py,sha256=o9euy_2ohR9PCU0rQV70LVnaX3CqI550tEueJggxg9I,4300
+modules/structure.py,sha256=CQzt22YvshqEB3wZIsJ7Iejqb3gqnEti5_GNy2e-83w,4868
+modules/transcriptomics.py,sha256=uMhwGu0-snyvtCIUWn2iYq0vmgNFyAOD7nnZ5ss3FI8,7113
+modules/variants.py,sha256=dz_G5AtmooxJdtD2eP5Gv9JswyPywYieuA-0szyqhPM,5619
+modules/visualization.py,sha256=DQs0_rZSiBFPaBiR1OzccDWcHjVvDX3MjblYcKTOTuA,8852
+transpiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+transpiler/parser.py,sha256=qobG29U3exKiliC23eYZ8HYSKwEK77GLTVnY7OD9CC0,9261
+transpiler/python_bridge.py,sha256=S1dUVIzFfFP0AhzdfOkJ-HJhcORNOedxDggnYCn5eFU,10441
+blixa-1.0.0.dist-info/METADATA,sha256=uhiVksffn9AjsqoVsRzv0Wp2-JDr_Tuu2jzw_3JkrEQ,702
+blixa-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+blixa-1.0.0.dist-info/entry_points.txt,sha256=X2z9ocVhe8gBvVAUu0Md_cV2JoFamXwUinsWbQR1ozw,50
+blixa-1.0.0.dist-info/top_level.txt,sha256=EzXHMRD7ieylbamlEXaeUOS0f60mysZDW3eHnM_T44E,35
+blixa-1.0.0.dist-info/RECORD,,

blixa-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

blixa-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+blixa = run:main
+run = run:main

blixa-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,23 @@
+# LICENSE
+
+MIT License
+
+Copyright (c) 2026 AHMED TARIG AHMED ABDALGLEEL
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

blixa-1.0.0.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+core
+exceptions
+modules
+transpiler

core/base.py

@@ -0,0 +1,88 @@
+# core/base.py
+
+from abc import ABC, abstractmethod
+from typing import Any, List, Dict
+
+class BioObject(ABC):
+    """
+    Abstract Base Class representing the core contract for all biological objects.
+    Enforces the 'SHARED METHODS' design (Section 3 of Core Syntax).
+    """
+
+    @abstractmethod
+    def value(self) -> Any:
+        """Get raw sequence or core value."""
+        pass
+
+    @abstractmethod
+    def len(self) -> int:
+        """Get the length of the object (e.g., sequence length or cell count)."""
+        pass
+
+    def __len__(self) -> int:
+        """Support for standard Python len() function."""
+        return self.len()
+
+    @abstractmethod
+    def at(self, pos: int) -> Any:
+        """Access item at a specific biological position (1-based index)."""
+        pass
+
+    @abstractmethod
+    def slice(self, start: int, end: int) -> 'BioObject':
+        """Extract a sub-part of the object."""
+        pass
+
+    @abstractmethod
+    def head(self, n: int = 5) -> 'BioObject':
+        """Get the first n elements."""
+        pass
+
+    @abstractmethod
+    def tail(self, n: int = 5) -> 'BioObject':
+        """Get the last n elements."""
+        pass
+
+    @abstractmethod
+    def find(self, pattern: Any) -> int:
+        """Find the first occurrence of a pattern."""
+        pass
+
+    @abstractmethod
+    def find_all(self, pattern: Any) -> List[int]:
+        """Find all occurrences of a pattern."""
+        pass
+
+    def rep(self, pattern: Any) -> int:
+        """Count repetitions of a pattern. Default implementation uses find_all()."""
+        return len(self.find_all(pattern))
+
+    @abstractmethod
+    def valid(self) -> bool:
+        """Quick validation check. Returns True if valid, False otherwise."""
+        pass
+
+    @abstractmethod
+    def validate(self) -> bool:
+        """Comprehensive biological validation. Should raise BioError if invalid."""
+        pass
+
+    @abstractmethod
+    def info(self) -> Dict[str, Any]:
+        """Return a dictionary containing brief information about the object."""
+        pass
+
+    @abstractmethod
+    def summary(self) -> str:
+        """Return a formatted string containing an extensive analytical summary."""
+        pass
+
+    @abstractmethod
+    def graph(self, graph_type: str, **kwargs) -> Any:
+        """Universal method for data visualization."""
+        pass
+
+    @abstractmethod
+    def save(self, file_path: str) -> None:
+        """Save the object data to a specified file."""
+        pass

core/cell.py

@@ -0,0 +1,168 @@
+# core/cell.py
+
+import json
+import math
+from typing import Any, List, Dict, Union
+from core.base import BioObject
+from exceptions.bio_errors import BiologicalLogicError, MissingDataError
+
+class Cell(BioObject):
+    """
+    Core Single Cell representation. 
+    Handles cell types, analytical labels, and single-cell gene expression mapping securely.
+    """
+
+    def __init__(self, cell_type: str = "unknown", expression_data: Dict[str, float] = None, strict: bool = True):
+        self._type = str(cell_type).strip()
+        self._label = "unlabeled"
+        self.strict = strict
+        
+        self._expression_data: Dict[str, float] = {}
+        
+        # Defensive Data Injection
+        if expression_data is not None:
+            if not isinstance(expression_data, dict):
+                raise BiologicalLogicError("error: expression_data must be a dictionary mapping gene names to numerical expression values.")
+                
+            for gene_name, expr_value in expression_data.items():
+                try:
+                    val = float(expr_value)
+                    # Clean out NaNs and enforce non-negative biological expression constraints
+                    if math.isnan(val) or val < 0:
+                        val = 0.0
+                    self._expression_data[str(gene_name).strip().upper()] = val
+                except (ValueError, TypeError):
+                    if self.strict:
+                        raise BiologicalLogicError(f"error: Invalid expression value '{expr_value}' for gene '{gene_name}'.")
+
+        if self.strict:
+            self.validate()
+
+    # --- PROPERTIES (Syntax: cell1.type = "neural") ---
+    @property
+    def type(self) -> str:
+        return self._type
+
+    @type.setter
+    def type(self, new_type: str):
+        self._type = str(new_type).strip()
+
+    @property
+    def label(self) -> str:
+        return self._label
+
+    @label.setter
+    def label(self, new_label: str):
+        self._label = str(new_label).strip()
+
+    # --- SHARED METHODS (Satisfying BioObject ABC) ---
+    def value(self) -> str:
+        return self._type
+
+    def len(self) -> int:
+        """Length of a cell represents the number of detected expressed genes."""
+        return len(self._expression_data)
+
+    def at(self, pos: int) -> Any:
+        raise BiologicalLogicError("error: at() is not conceptually applicable to a single cell outside a population.")
+
+    def slice(self, start: int, end: int) -> 'BioObject':
+        raise BiologicalLogicError("error: slice() is not conceptually applicable to a single cell.")
+
+    def head(self, n: int = 5) -> 'BioObject':
+        raise BiologicalLogicError("error: head() requires a sequence or population.")
+
+    def tail(self, n: int = 5) -> 'BioObject':
+        raise BiologicalLogicError("error: tail() requires a sequence or population.")
+
+    def find(self, pattern: Any) -> int:
+        raise BiologicalLogicError("error: find() is not applicable to a cell. Use .expression() to query genes.")
+
+    def find_all(self, pattern: Any) -> List[int]:
+        raise BiologicalLogicError("error: find_all() is not applicable to a cell. Use .expression() to query genes.")
+
+    def valid(self) -> bool:
+        return bool(self._type)
+
+    def validate(self) -> bool:
+        if not self.valid():
+            raise BiologicalLogicError("error: Cell type cannot be completely empty.")
+        return True
+
+    def info(self) -> Dict[str, Any]:
+        return {
+            "type": self.type,
+            "label": self.label,
+            "detected_genes": self.len()
+        }
+
+    def summary(self) -> str:
+        return f"Cell Summary: Type='{self.type}', Label='{self.label}', Expressed Genes: {self.len()}"
+
+    def graph(self, graph_type: str, **kwargs) -> Any:
+        print(f"[Visualization Engine] Graphing Cell: [{graph_type}] with params {kwargs}")
+        return None
+
+    def save(self, file_path: str) -> None:
+        """Saves the cell's profile and expression dictionary to a JSON file."""
+        data = {
+            "type": self.type,
+            "label": self.label,
+            "detected_genes": self.len(),
+            "expression": self._expression_data
+        }
+        try:
+            with open(file_path, "w") as f:
+                json.dump(data, f, indent=4)
+        except Exception as e:
+            raise BiologicalLogicError(f"error: Failed to save cell data to '{file_path}'. Details: {str(e)}")
+
+    # --- HELPER METHOD ---
+    def _extract_gene_name(self, obj: Any) -> str:
+        """Safely extracts the gene name whether the input is a string or a BioObject (Gene)."""
+        if isinstance(obj, BioObject):
+            return str(obj.value()).strip().upper()
+        return str(obj).strip().upper()
+
+    # --- CELL SPECIFIC METHODS (Section 8 of Syntax) ---
+    def expression(self, gene_or_genes: Union[Any, List[Any]]) -> Union[float, Dict[str, float]]:
+        """Get expression level of specific gene(s) (can pass string or Gene objects)."""
+        if not self._expression_data:
+            raise MissingDataError(f"error: No expression data loaded for this cell.")
+        
+        if isinstance(gene_or_genes, list):
+            return {
+                self._extract_gene_name(g): self._expression_data.get(self._extract_gene_name(g), 0.0) 
+                for g in gene_or_genes
+            }
+            
+        target_gene = self._extract_gene_name(gene_or_genes)
+        return self._expression_data.get(target_gene, 0.0)
+
+    def markers(self, target_type: str = None) -> Any:
+        """Analyze marker genes."""
+        raise BiologicalLogicError("error: markers() dynamic discovery requires 'use singlecell' module to cross-reference databases.")
+
+    def state(self) -> Any:
+        """Analyze cell state (stress, cell_cycle, etc.)."""
+        raise BiologicalLogicError("error: state() profiling requires 'use singlecell' module.")
+
+    # --- STEM CELL MODULE INTEGRATIONS ---
+    def pluripotency_score(self) -> float:
+        raise BiologicalLogicError("error: pluripotency_score() requires 'use stemcell' module.")
+
+    def differentiate(self, target_type: str) -> 'Cell':
+        raise BiologicalLogicError("error: differentiate() requires 'use stemcell' module.")
+
+    def reprogram(self, target_type: str = "iPSC") -> 'Cell':
+        raise BiologicalLogicError("error: reprogram() requires 'use stemcell' module.")
+
+    def lineage(self) -> Any:
+        raise BiologicalLogicError("error: lineage() requires 'use stemcell' module.")
+
+    def __repr__(self) -> str:
+        return f"cell('{self.type}', genes={self.len()})"
+
+# General Function Wrapper
+def cell(cell_type: str = "unknown", **kwargs) -> Cell:
+    return Cell(cell_type, **kwargs)

core/dna.py

@@ -0,0 +1,233 @@
+# core/dna.py
+
+import re
+from typing import Any, List, Dict, Union
+from core.base import BioObject
+from exceptions.bio_errors import SequenceValidationError, BiologicalLogicError
+
+class DNA(BioObject):
+    """
+    Core DNA sequence representation with strict validation, method chaining,
+    defensive error handling, and customizable biological/mathematical constants.
+    """
+    
+    DEFAULT_CONSTANTS = {
+        "VALID_BASES": set("ATGC"),
+        "GC_WEIGHT": 1.0  
+    }
+
+    def __init__(self, sequence: Any = "", strict: bool = True, custom_constants: dict = None):
+        if sequence is None:
+            sequence = ""
+        elif isinstance(sequence, BioObject):
+            sequence = str(sequence.value())
+            
+        if not isinstance(sequence, str):
+            sequence = str(sequence)
+            
+        self._seq = sequence.upper().strip()
+        self.strict = strict
+        
+        self.constants = self.DEFAULT_CONSTANTS.copy()
+        if custom_constants:
+            if "VALID_BASES" in custom_constants and not isinstance(custom_constants["VALID_BASES"], set):
+                custom_constants["VALID_BASES"] = set(custom_constants["VALID_BASES"])
+            self.constants.update(custom_constants)
+            
+        self._mutation_log: List[Dict[str, Any]] = []
+        
+        if self.strict:
+            self.validate()
+
+    def _get_inheritable_constants(self) -> Dict[str, Any]:
+        """Filters constants to pass only mathematical ones avoiding base set leakage."""
+        return {k: v for k, v in self.constants.items() if k != "VALID_BASES"}
+
+    # --- SHARED METHODS ---
+    def value(self) -> str:
+        return self._seq
+
+    def len(self) -> int:
+        return len(self._seq)
+
+    def at(self, pos: int) -> str:
+        if self.len() == 0:
+            raise BiologicalLogicError("error: sequence is empty.")
+        if pos < 1 or pos > self.len():
+            raise BiologicalLogicError(f"error: position {pos} is outside sequence length {self.len()}.")
+        return self._seq[pos - 1]
+
+    def slice(self, start: int, end: int) -> 'DNA':
+        if self.len() == 0:
+            return DNA("", strict=self.strict, custom_constants=self.constants)
+            
+        if start < 1 or end > self.len() or start > end:
+            raise BiologicalLogicError(f"error: invalid slice boundaries [{start}, {end}] for length {self.len()}.")
+            
+        return DNA(self._seq[start - 1 : end], strict=self.strict, custom_constants=self.constants)
+
+    def head(self, n: int = 5) -> 'DNA':
+        if n < 0:
+            raise BiologicalLogicError("error: head() requires a non-negative integer.")
+        return DNA(self._seq[:n], strict=self.strict, custom_constants=self.constants)
+
+    def tail(self, n: int = 5) -> 'DNA':
+        if n < 0:
+            raise BiologicalLogicError("error: tail() requires a non-negative integer.")
+        if n == 0:
+            return DNA("", strict=self.strict, custom_constants=self.constants)
+        return DNA(self._seq[-n:], strict=self.strict, custom_constants=self.constants)
+
+    def find(self, pattern: Any) -> int:
+        idx = self._seq.find(str(pattern).upper())
+        return idx + 1 if idx != -1 else 0
+
+    def find_all(self, pattern: Any) -> List[int]:
+        pattern_str = str(pattern).upper()
+        if not pattern_str:
+            return []
+        return [m.start() + 1 for m in re.finditer(f"(?={pattern_str})", self._seq)]
+
+    def valid(self) -> bool:
+        if not self._seq:
+            return True
+        return set(self._seq).issubset(self.constants["VALID_BASES"])
+
+    def validate(self) -> bool:
+        if not self.valid():
+            invalid_chars = set(self._seq) - self.constants["VALID_BASES"]
+            raise SequenceValidationError(f"error: invalid dna base(s) {list(invalid_chars)} found.")
+        return True
+
+    def info(self) -> Dict[str, Any]:
+        return {"type": "DNA", "length": self.len(), "gc": self.gc()}
+
+    def summary(self) -> str:
+        return f"DNA Summary: {self.len()} bp, GC: {self.gc()}%\nComposition: {self.composition()}"
+
+    def graph(self, graph_type: str = "default", **kwargs) -> Any:
+        print(f"[Visualization Engine] Graphing DNA: [{graph_type}] with params {kwargs}")
+        return None
+
+    def save(self, file_path: str) -> None:
+        try:
+            with open(file_path, "w") as f:
+                f.write(self._seq)
+        except Exception as e:
+            raise BiologicalLogicError(f"error: Failed to save DNA sequence to '{file_path}'. Details: {str(e)}")
+
+    # --- DNA SPECIFIC METHODS ---
+    def gc(self) -> float:
+        if not self._seq:
+            return 0.0
+        g = self._seq.count('G')
+        c = self._seq.count('C')
+        result = ((g + c) / self.len()) * 100 * self.constants.get("GC_WEIGHT", 1.0)
+        return round(result, 2)
+
+    def rev(self) -> 'DNA':
+        return DNA(self._seq[::-1], strict=self.strict, custom_constants=self.constants)
+
+    def comp(self) -> 'DNA':
+        trans = str.maketrans("ATGCURYKMSWBDHVN", "TACGAYRMKWSVHDBN")
+        return DNA(self._seq.translate(trans), strict=self.strict, custom_constants=self.constants)
+
+    def rev_comp(self) -> 'DNA':
+        return self.rev().comp()
+
+    def set(self, pos: int, base: str) -> 'DNA':
+        if pos < 1 or pos > self.len():
+            raise BiologicalLogicError(f"error: position {pos} is out of bounds.")
+        seq_list = list(self._seq)
+        seq_list[pos - 1] = str(base).upper()
+        return DNA("".join(seq_list), strict=self.strict, custom_constants=self.constants)
+
+    def insert(self, pos: int, base: str) -> 'DNA':
+        if pos < 1 or pos > self.len() + 1:
+            raise BiologicalLogicError(f"error: position {pos} is out of bounds for insertion.")
+        seq_list = list(self._seq)
+        seq_list.insert(pos - 1, str(base).upper())
+        return DNA("".join(seq_list), strict=self.strict, custom_constants=self.constants)
+
+    def delete(self, pos: int) -> 'DNA':
+        if pos < 1 or pos > self.len():
+            raise BiologicalLogicError(f"error: position {pos} is out of bounds.")
+        seq_list = list(self._seq)
+        seq_list.pop(pos - 1)
+        return DNA("".join(seq_list), strict=self.strict, custom_constants=self.constants)
+
+    def mutate(self, pos: int, base: str) -> 'DNA':
+        orig = self.at(pos)
+        mutated_dna = self.set(pos, base)
+        mutated_dna._mutation_log = list(self._mutation_log)
+        mutated_dna._mutation_log.append({
+            "position": pos,
+            "original": orig,
+            "new": str(base).upper(),
+            "type": "substitution"
+        })
+        return mutated_dna
+
+    def composition(self) -> Dict[str, int]:
+        return {b: self._seq.count(b) for b in self.constants["VALID_BASES"]}
+
+    def codons(self) -> List[str]:
+        return [self._seq[i:i+3] for i in range(0, self.len() - self.len() % 3, 3)]
+
+    def motifs(self) -> Dict[str, List[int]]:
+        """Scans for fundamental biological motifs and returns their 1-based start positions."""
+        standard_motifs = {
+            "TATA_BOX": "TATAAA",
+            "CAAT_BOX": "CCAAT",
+            "GC_BOX": "GGGCGG"
+        }
+        found_motifs = {}
+        for name, pattern in standard_motifs.items():
+            positions = self.find_all(pattern)
+            if positions:
+                found_motifs[name] = positions
+        return found_motifs
+
+    def motif(self, name: str) -> List[int]:
+        return self.find_all(name)
+
+    def promoter(self, upstream: int = 50) -> 'DNA':
+        return self.head(min(upstream, self.len()))
+
+    def orfs(self) -> List['DNA']:
+        orfs_list = []
+        seq_len = self.len()
+        if seq_len < 3:
+            return orfs_list
+            
+        stop_codons = {"TAA", "TAG", "TGA"}
+        for i in range(seq_len - 2):
+            if self._seq[i:i+3] == "ATG":
+                for j in range(i + 3, seq_len - 2, 3):
+                    codon = self._seq[j:j+3]
+                    if codon in stop_codons:
+                        orfs_list.append(self.slice(i + 1, j + 3))
+                        break
+        return orfs_list
+
+    def transcribe(self) -> 'BioObject':
+        from core.rna import RNA
+        rna_seq = self._seq.replace("T", "U")
+        return RNA(rna_seq, strict=self.strict, custom_constants=self._get_inheritable_constants())
+
+    def translate(self) -> 'BioObject':
+        return self.transcribe().translate()
+        
+    def methylation(self) -> Any:
+        raise BiologicalLogicError("error: methylation() analysis requires 'use epigenetics' module.")
+        
+    def snp(self) -> Any:
+        raise BiologicalLogicError("error: snp() variant calling requires 'use variants' module.")
+
+    def __repr__(self) -> str:
+        preview = f"{self._seq[:20]}..." if self.len() > 20 else self._seq
+        return f"dna('{preview}')"
+
+# General Function Wrapper
+def dna(sequence: Any = "", **kwargs) -> DNA:
+    return DNA(sequence, **kwargs)