### Install molmass package

Source: https://github.com/cgohlke/molmass/blob/master/README.rst

Install the molmass package and all dependencies from the Python Package Index. Use the '[all]' extra to include optional dependencies.

```bash
python -m pip install -U "molmass[all]"
```

--------------------------------

### Start Web Application

Source: https://context7.com/cgohlke/molmass/llms.txt

Initiate the molmass web server, optionally specifying URL and browser behavior.

```python
from molmass.web import main, response

# Start web server (opens browser automatically)
# main()  # Runs at http://127.0.0.1:5001/

# Custom URL without browser
# main(url='http://localhost:8080/', open_browser=False)
```

--------------------------------

### Flask Integration Example

Source: https://context7.com/cgohlke/molmass/llms.txt

Integrate molmass's response functionality into a Flask application.

```python
from flask import Flask, request
from molmass.web import response

app = Flask(__name__)

@app.route('/', methods=['GET'])
def calculator():
    return response(request.args, url=request.base_url)

if __name__ == '__main__':
    app.run(port=5000)
```

--------------------------------

### Run molmass web application

Source: https://github.com/cgohlke/molmass/blob/master/README.rst

Run the molmass web application. This requires the 'Flask' dependency to be installed.

```bash
python -m molmass --web
```

--------------------------------

### Get Elemental Composition

Source: https://context7.com/cgohlke/molmass/llms.txt

The `composition()` method provides a detailed breakdown of a molecule's elemental composition, including atom counts, relative masses, and mass fractions for each element.

```python
from molmass import Formula

caffeine = Formula('C8H10N4O2')
composition = caffeine.composition()

# Iterate over composition
for symbol in composition:
    item = composition[symbol]
    print(f"{item.symbol}: {item.count} atoms, "
          f"mass={item.mass:.4f}, fraction={item.fraction:.4f}")
# Output:
# C: 8 atoms, mass=96.0859, fraction=0.4948
# H: 10 atoms, mass=10.0794, fraction=0.0519

```

--------------------------------

### Get Total Composition

Source: https://context7.com/cgohlke/molmass/llms.txt

Calculates and prints the total atom count and mass of a chemical composition. Exports composition data to tuples, dictionaries, or pandas DataFrames.

```python
from molmass import Formula

# Example composition (assuming 'composition' is a Formula object)
# composition = Formula('C8H10N4O2') # Caffeine example

# Get total composition
total = composition.total
print(f"Total atoms: {total.count}, Total mass: {total.mass:.4f}")

# Export as different formats
print(composition.astuple())
print(composition.asdict())

# Convert to pandas DataFrame (requires pandas)
df = composition.dataframe()
print(df)
```

```python
isotopic_formula = Formula('[12C][13C]C')
comp_isotopic = isotopic_formula.composition(isotopic=True)
for item in comp_isotopic.values():
    print(f"{item.symbol}: {item.count}, mass={item.mass:.4f}")
```

--------------------------------

### Command-Line Usage

Source: https://context7.com/cgohlke/molmass/llms.txt

Execute molmass calculations and access help via the command line.

```bash
python -m molmass C8H10N4O2
```

```bash
python -m molmass "CuSO4.5H2O"
```

```bash
python -m molmass --help
```

```bash
python -m molmass --web
```

```bash
python -m molmass --web --url http://localhost:8080/
```

```bash
python -m molmass --web --nobrowser
```

--------------------------------

### Calculate Empirical Formulas from Mass Fractions

Source: https://context7.com/cgohlke/molmass/llms.txt

Demonstrates calculating empirical formulas from elemental mass percentages. Supports standard elements, isotopes, and verification of the resulting formula's mass.

```python
from molmass import from_fractions, Formula

# Water from mass fractions
water_formula = from_fractions({'H': 0.112, 'O': 0.888})
print(f"Formula: {water_formula}")  # 'H2O'

# Heavy water with deuterium
heavy_water = from_fractions({'D': 0.2, 'O': 0.8})
print(f"Formula: {heavy_water}")    # 'O[2H]2'

# Organic compound analysis
# Given: C=59.39%, H=8.97%, O=31.64%
organic = from_fractions({'C': 59.39, 'H': 8.97, 'O': 31.64})
print(f"Formula: {organic}")        # 'C5H9O2'

# With specific isotopes
silica = from_fractions({'O': 0.26, '30Si': 0.74})
print(f"Formula: {silica}")         # 'O2[30Si]3'

# Verify the result
f = Formula(organic)
print(f"Empirical formula: {f.empirical}")
print(f"Mass: {f.mass:.4f}")
```

--------------------------------

### Create and Analyze Charged Oligonucleotides

Source: https://context7.com/cgohlke/molmass/llms.txt

Demonstrates creating a charged oligonucleotide formula and accessing its charge and m/z ratio. Also shows how to view formulas for deoxynucleotides and ribonucleotides.

```python
from molmass import Formula

charged_rna = Formula('ssrna(AUCG)_2+')
print(f"Charge: {charged_rna.charge}")
print(f"m/z: {charged_rna.mz:.4f}")

# View nucleotide formulas (monophosphate minus H2O)
print("\nDeoxynucleotides:")
for code, formula in DEOXYNUCLEOTIDES.items():
    print(f"  d{code}: {formula}")
# dA: C10H12N5O5P
# dT: C10H13N2O7P
# dC: C9H12N3O6P
# dG: C10H12N5O6P

print("\nRibonucleotides:")
for code, formula in NUCLEOTIDES.items():
    print(f"  {code}: {formula}")
```

--------------------------------

### Analyze Formula with analyze() Function

Source: https://context7.com/cgohlke/molmass/llms.txt

Shows how to use the `analyze()` function for comprehensive formula analysis, returning a formatted string with detailed composition and mass distribution. The `min_intensity` parameter can filter results.

```python
from molmass import analyze, main

# Complete analysis as formatted string
result = analyze('C8H10N4O2', min_intensity=0.01)
print(result)
# Output:
# Formula: C8H10N4O2
# Empirical formula: C4H5N2O
#
# Nominal mass: 194
# Average mass: 194.19095
# Monoisotopic mass: 194.08038 (89.883%)
# Most abundant mass: 194.08038 (89.883%)
# Mean of distribution: 194.18604
#
# Number of atoms: 24
#
# Elemental Composition
#
# Element  Count  Relative mass  Fraction %
# C            8       96.08592     49.4801
# H           10       10.07941      5.1905
# N            4       56.02681     28.8514
# O            2       31.99881     16.4780
#
# Mass Distribution
#
# A    Relative mass  Fraction %  Intensity %
# 194      194.08038   89.882781   100.000000
# 195      195.08287    9.262511    10.305100
# 196      196.08497    0.802196     0.892492
```

--------------------------------

### Print console script usage

Source: https://github.com/cgohlke/molmass/blob/master/README.rst

Print the help message for the molmass console script to see available options and commands.

```bash
python -m molmass --help
```

--------------------------------

### Create Custom Isotope

Source: https://context7.com/cgohlke/molmass/llms.txt

Instantiate a custom Isotope object with specified properties.

```python
custom_iso = Isotope(mass=12.0, abundance=1.0, massnumber=12, charge=0)
print(f"m/z ratio: {custom_iso.mz}")
```

--------------------------------

### Formula Class Initialization

Source: https://context7.com/cgohlke/molmass/llms.txt

The Formula class is the primary interface for parsing chemical formulas and calculating molecular properties.

```APIDOC
## Formula Class Initialization

### Description
Creates a new Formula object from a chemical notation string, allowing access to molecular mass, composition, and other properties.

### Parameters
#### Request Body
- **formula** (string) - Required - The chemical formula string (e.g., 'C8H10N4O2', 'D2O', 'SO4_2-').

### Response
- **formula** (string) - The normalized chemical formula in Hill notation.
- **mass** (float) - The average molecular mass.
- **nominal_mass** (int) - The nominal molecular mass.
- **monoisotopic_mass** (float) - The monoisotopic mass.
- **charge** (int) - The ionic charge of the molecule.
```

--------------------------------

### Access Element Properties Database

Source: https://context7.com/cgohlke/molmass/llms.txt

Shows how to access detailed physicochemical data for elements using their symbol, name, or atomic number. Includes basic properties, periodic table position, physical properties, electronic properties, ionization energies, and isotope data.

```python
from molmass import ELEMENTS, Element

# Access element by symbol, name, or atomic number
carbon = ELEMENTS['C']
carbon_by_name = ELEMENTS['Carbon']
carbon_by_number = ELEMENTS[6]

# Basic properties
print(f"Symbol: {carbon.symbol}")           # 'C'
print(f"Name: {carbon.name}")               # 'Carbon'
print(f"Atomic number: {carbon.number}")    # 6
print(f"Atomic mass: {carbon.mass:.4f}")    # 12.0107

# Periodic table position
print(f"Group: {carbon.group}")             # 14
print(f"Period: {carbon.period}")           # 2
print(f"Block: {carbon.block}")             # 'p'

# Physical properties
print(f"Density: {carbon.density} g/cm³")   # 3.51
print(f"Melting point: {carbon.tmelt} K")   # 3825.0
print(f"Boiling point: {carbon.tboil} K")   # 5100.0

# Electronic properties
print(f"Electronegativity: {carbon.eleneg}")          # 2.55
print(f"Electron affinity: {carbon.eleaffin} eV")     # 1.262118
print(f"Electron config: {carbon.eleconfig}")         # '[He] 2s2 2p2'
print(f"Config dict: {carbon.eleconfig_dict}")
# {(1, 's'): 2, (2, 's'): 2, (2, 'p'): 2}

# Ionization energies (eV)
print(f"1st ionization: {carbon.ionenergy[0]} eV")    # 11.2603

# Isotope data
print(f"Nominal mass: {carbon.nominalmass}")          # 12
for massnumber, isotope in carbon.isotopes.items():
    print(f"  {massnumber}C: mass={isotope.mass:.6f}, "
          f"abundance={isotope.abundance:.4%}")
# 12C: mass=12.000000, abundance=98.93%
# 13C: mass=13.003355, abundance=1.07%

# Iterate all elements
print(f"\nTotal elements: {len(ELEMENTS)}")  # 109
total_mass = sum(e.mass for e in ELEMENTS)
print(f"Sum of atomic masses: {total_mass:.4f}")
```

--------------------------------

### Fundamental Particle Properties

Source: https://context7.com/cgohlke/molmass/llms.txt

Access and print the mass and charge of fundamental particles like electrons, protons, and neutrons.

```python
print(f"\nElectron mass: {ELECTRON.mass:.10f}")      # ~0.000548579909
print(f"Proton mass: {PROTON.mass:.10f}")            # ~1.007276467
print(f"Neutron mass: {NEUTRON.mass:.10f}")          # ~1.008664916
print(f"Elementary charge: {ELEMENTARY_CHARGE:.10e} C")  # 1.602e-19
```

--------------------------------

### Generate HTML Response

Source: https://context7.com/cgohlke/molmass/llms.txt

Create an HTML response for custom integration with the molmass web service.

```python
html = response(
    form={'q': 'C8H10N4O2'},
    url='http://example.com/molmass'
)
```

--------------------------------

### Perform Formula Arithmetic Operations

Source: https://context7.com/cgohlke/molmass/llms.txt

Illustrates how to combine and manipulate chemical formulas using addition, multiplication, and subtraction. Supports scalar multiplication and complex combinations.

```python
from molmass import Formula

# Addition of formulas
water = Formula('H2O')
hydroxide = Formula('HO-')
combined = water + hydroxide
print(f"Combined: {combined.formula}")     # Formula string
print(f"Charge: {combined.charge}")        # -1

# Multiplication
double_hydroxide = Formula('HO-') * 2
print(f"2x HO-: {double_hydroxide.expanded}")  # '[(HO)2]2-'
print(f"Charge: {double_hydroxide.charge}")    # -2

# Left multiplication
triple_water = 3 * Formula('H2O')
print(f"3x H2O mass: {triple_water.mass:.4f}")

# Subtraction
water = Formula('H2O')
oxygen = Formula('O')
hydrogen = water - oxygen
print(f"H2O - O = {hydrogen.formula}")     # 'H2'

# Complex arithmetic
hydrate = Formula('CuSO4') + (5 * Formula('H2O'))
print(f"Hydrate: {hydrate.formula}")
print(f"Mass: {hydrate.mass:.4f}")
```

--------------------------------

### Access Isotope Data

Source: https://context7.com/cgohlke/molmass/llms.txt

Retrieve and display detailed isotope information for elements.

```python
from molmass import ELEMENTS, Isotope
from molmass.elements import ELECTRON, PROTON, NEUTRON, ELEMENTARY_CHARGE

# Access isotope data
carbon = ELEMENTS['C']
for massnumber, isotope in carbon.isotopes.items():
    print(f"Carbon-{massnumber}:")
    print(f"  Mass: {isotope.mass:.6f}")
    print(f"  Abundance: {isotope.abundance:.4%}")
    print(f"  Mass number: {isotope.massnumber}")
```

--------------------------------

### Parse Chemical Formulas and Access Properties

Source: https://context7.com/cgohlke/molmass/llms.txt

Use the Formula class to parse chemical notations and retrieve molecular properties like average mass, nominal mass, monoisotopic mass, and atom count. Supports isotope specifications and ionic charges.

```python
from molmass import Formula

# Create formula from chemical notation
caffeine = Formula('C8H10N4O2')

# Access molecular properties
print(f"Formula: {caffeine.formula}")           # 'C8H10N4O2' (Hill notation)
print(f"Empirical: {caffeine.empirical}")       # 'C4H5N2O'
print(f"Average mass: {caffeine.mass:.4f}")     # 194.1909 g/mol
print(f"Nominal mass: {caffeine.nominal_mass}") # 194
print(f"Monoisotopic: {caffeine.monoisotopic_mass:.4f}")  # 194.0804
print(f"Atoms: {caffeine.atoms}")               # 24
print(f"Charge: {caffeine.charge}")             # 0

# Isotope-specific formulas
heavy_water = Formula('D2O')  # Deuterium oxide
print(f"D2O formula: {heavy_water.formula}")    # '[2H]2O'
print(f"D2O mass: {heavy_water.mass:.4f}")      # 20.0276

# Specific isotopes
si30_oxide = Formula('[30Si]3O2')
print(f"Mass: {si30_oxide.mass:.4f}")           # 121.8959

# Ionic compounds with charges
sulfate = Formula('SO4_2-')
print(f"Charge: {sulfate.charge}")              # -2
print(f"Mass: {sulfate.mass:.4f}")              # 96.0635
print(f"m/z ratio: {sulfate.mz:.4f}")           # 48.0318

arsenate = Formula('[AsO4]3-')
print(f"Charge: {arsenate.charge}")             # -3

```

--------------------------------

### Calculate Mass of Ion

Source: https://context7.com/cgohlke/molmass/llms.txt

Use the Formula class to calculate the mass of an ion, such as H+.

```python
# Use in calculations (proton as H+)
proton_formula = Formula('1H+')
print(f"H+ mass: {proton_formula.mass:.10f}")        # Same as PROTON.mass
```

--------------------------------

### Elemental Composition

Source: https://context7.com/cgohlke/molmass/llms.txt

Retrieves the detailed elemental breakdown of a molecule.

```APIDOC
## composition()

### Description
Returns a dictionary-like object containing the elemental breakdown of the formula, including atom counts, relative masses, and mass fractions.

### Response
- **symbol** (object) - A dictionary where keys are element symbols and values contain:
  - **count** (int) - Number of atoms.
  - **mass** (float) - Total mass contribution of the element.
  - **fraction** (float) - Mass fraction of the element in the molecule.
```

--------------------------------

### Handle Hydrates and Arithmetic Operations

Source: https://context7.com/cgohlke/molmass/llms.txt

Molmass supports arithmetic notation for hydrates and compound mixtures using '.', '+', and '*' operators. This allows for calculations of complex compounds like hydrated salts.

```python
from molmass import Formula

# Hydrates using dot notation
copper_sulfate_hydrate = Formula('CuSO4.5H2O')
print(f"Expanded: {copper_sulfate_hydrate.expanded}")  # 'CuSO4(H2O)5'
print(f"Formula: {copper_sulfate_hydrate.formula}")    # 'CuH10O9S'
print(f"Mass: {copper_sulfate_hydrate.mass:.4f}")      # 249.6849

# Using + and * operators
same_hydrate = Formula('CuSO4+5*H2O')
print(f"Mass: {same_hydrate.mass:.4f}")                # 249.6849

# Salt forms
aniline_hcl = Formula('PhNH2.HCl')
print(f"Formula: {aniline_hcl.formula}")               # 'C6H8ClN'
print(f"Mass: {aniline_hcl.mass:.4f}")                 # 129.5876

# Ammonia borane
ammonia_bf3 = Formula('NH3.BF3')
print(f"Formula: {ammonia_bf3.formula}")               # 'BF3H3N'

# Multiple water molecules
water_5 = Formula('5*H2O')
print(f"Mass: {water_5.mass:.4f}")                     # 90.0764

```

--------------------------------

### Analyze Large Molecules

Source: https://context7.com/cgohlke/molmass/llms.txt

Use the analyze function to skip spectrum calculations for very large molecules.

```python
result = analyze('C1000H1000', maxatoms=100)  # Spectrum skipped
```

--------------------------------

### Calculate molecular properties from chemical formula

Source: https://github.com/cgohlke/molmass/blob/master/README.rst

Calculate the molecular mass, elemental composition, and mass distribution of a molecule using its chemical formula. The Formula object provides attributes for average mass, nominal mass, monoisotopic mass, atom count, charge, and detailed composition.

```python
>>> from molmass import Formula
>>> f = Formula('C8H10N4O2')  # Caffeine
>>> f
Formula('C8H10N4O2')
>>> f.formula  # hill notation
'C8H10N4O2'
>>> f.empirical
'C4H5N2O'
>>> f.mass  # average mass
194.1909...
>>> f.nominal_mass  # == f.isotope.massnumber
194
>>> f.monoisotopic_mass  # == f.isotope.mass
194.0803...
>>> f.atoms
24
>>> f.charge
0
```

```python
>>> f.composition().dataframe()
         Count  Relative mass  Fraction
Element...
C            8      96.085920  0.494801
H           10      10.079410  0.051905
N            4      56.026812  0.288514
O            2      31.998810  0.164780
```

```python
>>> f.spectrum(min_intensity=0.01).dataframe()
             Relative mass  Fraction  Intensity %         m/z
Mass number...
194             194.080376  0.898828   100.000000  194.080376
195             195.082873  0.092625    10.305100  195.082873
196             196.084968  0.008022     0.892492  196.084968
197             197.087214  0.000500     0.055681  197.087214
```

--------------------------------

### Access chemical element properties

Source: https://github.com/cgohlke/molmass/blob/master/README.rst

Access physicochemical and descriptive properties of chemical elements using the ELEMENTS dictionary or Element class. Properties include atomic number, symbol, name, group, period, electronic configuration, and isotopic data.

```python
>>> from molmass import ELEMENTS, Element
>>> e = ELEMENTS['C']
>>> e
Element(
    6, 'C', 'Carbon',
    group=14, period=2, block='p', series=1,
    mass=12.01074, eleneg=2.55, eleaffin=1.262118,
    covrad=0.77, atmrad=0.91, vdwrad=1.7,
    tboil=5100.0, tmelt=3825.0, density=3.51,
    eleconfig='[He] 2s2 2p2',
    oxistates='4*, 2, -4*',
    ionenergy=(
        11.2603, 24.383, 47.877, 64.492, 392.077,
        489.981,
    ),
    isotopes={
        12: Isotope(12.0, 0.9893, 12),
        13: Isotope(13.00335483507, 0.0107, 13),
    },
)
```

```python
>>> e.number
6
>>> e.symbol
'C'
>>> e.name
'Carbon'
>>> e.description
'Carbon is a member of group 14 of the periodic table...'
>>> e.eleconfig
'[He] 2s2 2p2'
>>> e.eleconfig_dict
{(1, 's'): 2, (2, 's'): 2, (2, 'p'): 2}
```

```python
>>> str(ELEMENTS[6])
'Carbon'
>>> len(ELEMENTS)
109
>>> sum(e.mass for e in ELEMENTS)
14693.181589001...
```

```python
>>> for e in ELEMENTS:
...     e.validate()
...
```

--------------------------------

### Use Chemical Group Abbreviations

Source: https://context7.com/cgohlke/molmass/llms.txt

Molmass recognizes common chemical group abbreviations for functional groups, amino acids, and protecting groups. These abbreviations expand into their full chemical formulas.

```python
from molmass import Formula, GROUPS

# Ethanol using Et abbreviation
ethanol = Formula('EtOH')
print(f"Expanded: {ethanol.expanded}")    # '(C2H5)OH'
print(f"Formula: {ethanol.formula}")      # 'C2H6O'
print(f"Mass: {ethanol.mass:.4f}")        # 46.0685

# Phenyl group
phenol = Formula('PhOH')
print(f"Formula: {phenol.formula}")       # 'C6H6O'

# Bipyridine ligand
bpy = Formula('Bpy')
print(f"Formula: {bpy.formula}")          # 'C10H8N2'

# Boc protecting group
boc = Formula('Boc')
print(f"Formula: {boc.formula}")          # 'C5H9O2'

# Complex organometallic compound
complex_mol = Formula('Co(Bpy)(CO)4')
print(f"Formula: {complex_mol.formula}")  # 'C14H8CoN2O4'
print(f"Mass: {complex_mol.mass:.4f}")    # 327.1581

# View all available group abbreviations
print(f"Available groups: {len(GROUPS)}")  # ~100 groups
# Sample: 'Et', 'Me', 'Ph', 'Boc', 'Fmoc', 'Trt', 'Ala', 'Gly', etc.

```

--------------------------------

### Calculate Isotopic Mass Distribution Spectrum

Source: https://context7.com/cgohlke/molmass/llms.txt

Calculates and analyzes the isotopic mass distribution spectrum for a given molecule. Allows filtering by minimum intensity and exporting to a pandas DataFrame. Handles charged species by showing m/z values.

```python
from molmass import Formula

# Simple molecule spectrum
water = Formula('H2O')
spectrum = water.spectrum()

print(f"Peak mass: {spectrum.peak.mass:.4f}")
print(f"Mean mass: {spectrum.mean:.4f}")
print(f"Mass range: {spectrum.range}")

# Iterate over spectrum entries
for massnumber in spectrum:
    entry = spectrum[massnumber]
    print(f"A={entry.massnumber}: mass={entry.mass:.4f}, "
          f"fraction={entry.fraction:.4%}, intensity={entry.intensity:.2f}%")
```

```python
caffeine = Formula('C8H10N4O2')
spectrum = caffeine.spectrum(min_intensity=0.01)

print("\nCaffeine mass distribution:")
for entry in spectrum.values():
    print(f"  {entry.massnumber}: {entry.mass:.4f} ({entry.intensity:.2f}%")
```

```python
# Export to pandas DataFrame
df = spectrum.dataframe()
print(df)
```

```python
# Spectrum for charged species shows m/z
sulfate = Formula('SO4_2-')
spectrum = sulfate.spectrum(min_intensity=0.1)
for entry in spectrum.values():
    print(f"A={entry.massnumber}: m/z={entry.mz:.4f}")
```

--------------------------------

### Calculate Peptide Molecular Properties

Source: https://context7.com/cgohlke/molmass/llms.txt

Calculates molecular formulas and masses for peptide sequences using single-letter amino acid codes. Supports explicit peptide function and charged species.

```python
from molmass import Formula, from_peptide, AMINOACIDS

# Direct peptide sequence input
peptide = Formula('MDRGEQGLLK')
print(f"Formula: {peptide.formula}")
print(f"Mass: {peptide.mass:.4f}")
print(f"Atoms: {peptide.atoms}")
```

```python
sequence = 'GPAVLIMCFYWHKRQNEDST'  # All 20 standard amino acids
formula_str = from_peptide(sequence)
peptide = Formula(formula_str)
print(f"All 20 AA mass: {peptide.mass:.4f}")
```

```python
dipeptide = Formula('GG')  # Glycine-Glycine
print(f"Gly-Gly formula: {dipeptide.formula}")
print(f"Gly-Gly mass: {dipeptide.mass:.4f}")
```

```python
explicit_peptide = Formula('peptide(CPK)')
print(f"Cys-Pro-Lys mass: {explicit_peptide.mass:.4f}")
```

```python
charged_peptide = Formula('GPAVLIMCFYWHKRQNEDST_2+')
print(f"Charge: {charged_peptide.charge}")
print(f"m/z: {charged_peptide.mz:.4f}")
```

```python
# View amino acid formulas (residue weights minus H2O)
for code, formula in list(AMINOACIDS.items())[:5]:
    print(f"{code}: {formula}")
```

--------------------------------

### Calculate Nucleotide Sequence Molecular Properties

Source: https://context7.com/cgohlke/molmass/llms.txt

Calculates molecular properties for DNA and RNA sequences, including single and double-stranded forms. Auto-detects sequence type based on base composition.

```python
from molmass import Formula, from_oligo, DEOXYNUCLEOTIDES, NUCLEOTIDES

# DNA sequence (auto-detected as ssDNA)
dna = Formula('CGCGAATTCGCG')  # EcoRI recognition sequence
print(f"ssDNA mass: {dna.mass:.4f}")
```

```python
# Explicit single-stranded DNA
ssdna = Formula('ssdna(ATCG)')
print(f"ssDNA formula: {ssdna.formula}")
```

```python
# Double-stranded DNA
dsdna_formula = from_oligo('ATCG', 'dsdna')
dsdna = Formula(dsdna_formula)
print(f"dsDNA mass: {dsdna.mass:.4f}")
```

```python
# RNA sequences (auto-detected by presence of U)
rna = Formula('AUCG')  # Contains Uracil
print(f"ssRNA mass: {rna.mass:.4f}")
```

```python
# Double-stranded RNA
dsrna = Formula('dsrna(CCUU)')
print(f"dsRNA mass: {dsrna.mass:.4f}")
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.