classes-objects.ipynb

{
 "cells": [
  {
   "cell_type": "raw",
   "id": "0a61c1cb-9478-4096-97f6-031626de6e4f",
   "metadata": {},
   "source": [
    "---\n",
    "title: \"Brief intro to object-oriented programming\"\n",
    "author: \"Kyle Niemeyer\"\n",
    "date: \"13 January 2025\"\n",
    "institute: \"Oregon State University\"\n",
    "format:\n",
    "  revealjs:\n",
    "    output-file: classes-objects-revealjs.html\n",
    "    incremental: true\n",
    "    toc: false\n",
    "  html: default\n",
    "jupyter: python3\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11383237-2f95-4bb9-a017-76dd6e8e3b23",
   "metadata": {},
   "source": [
    "# Using classes and objects for research code\n",
    "\n",
    "## Brief intro to object-oriented programming\n",
    "\n",
    "::: {.fragment}\n",
    "***Classes***: organize data, methods, and functions\n",
    ":::\n",
    "\n",
    "::: {.fragment}\n",
    "**Objects**: manifestations of classes\n",
    ":::\n",
    "\n",
    "::: {.fragment} \n",
    "We can use object-oriented programming to cleanly organize behaviors and data in our code.\n",
    ":::\n",
    "\n",
    "## Object Orientation\n",
    "\n",
    "::: {.fragment}\n",
    "It provides a framework for classifying distinct concepts into comprehensible sizes.\n",
    "These smaller conceptual units facilitate cleaner, more scalable modeling.\n",
    ":::\n",
    "\n",
    "## Object Orientation\n",
    "\n",
    "- Classes and objects combine functions with data to make both easier to manage.\n",
    "- A class defines the behaviors of a new kind of thing, while an object is a particular thing.\n",
    "- Classes have constructors that describe how to create a new object of a particular kind.\n",
    "- An interface describes what an object can do; an implementation defines how.\n",
    "- One class can inherit from another and override just those things that it wants to change.\n",
    "\n",
    "## Object Orientation\n",
    "\n",
    "- *Encapsulation* is the property of owning data\n",
    "- *Inheritance* establishes a relationship hierarchy between models\n",
    "- *Polymorphism* allows for models to customize their own behavior even when they are based on other models\n",
    "\n",
    "# Objects\n",
    "\n",
    "::: {.fragment}\n",
    "**Everything** in Python is an object.\n",
    "::: \n",
    "\n",
    "::: {.fragment}\n",
    "All objects in Python have attributes and methods.\n",
    ":::\n",
    "\n",
    "## Object example: integers\n",
    "\n",
    "``` {.python .fragment}\n",
    "a = 1\n",
    "help(a) # gives info about the object\n",
    "dir(a) # gives list of data and behaviors associated with class\n",
    "```\n",
    "\n",
    "## Object example: integers\n",
    "\n",
    "``` {.python}\n",
    "a = 1\n",
    "help(a) # gives info about the object\n",
    "dir(a) # gives list of data and behaviors associated with class\n",
    "```\n",
    "\n",
    "::: {.aside}\n",
    "What do double underscores around `__abs__` mean?\n",
    ":::\n",
    "\n",
    "::: {.aside .fragment}\n",
    "From [PEP8](https://www.python.org/dev/peps/pep-0008/): \"magic objects or attributes that live in user-controlled namespaces.\n",
    "E.g., `__init__`, `__import__`, or `__file__`. Never invent such names; only use them as documented.\"\n",
    ":::\n",
    "\n",
    "::: {.aside .fragment}\n",
    "Generally don't call dunder methods directly; instead, use built-in functions.\n",
    ":::\n",
    "\n",
    "## ... what about functions?\n",
    "\n",
    "``` {.python .fragment}\n",
    "import math\n",
    "dir(math.sin)\n",
    "```\n",
    "\n",
    "::: {.fragment}\n",
    "Even functions are objects!\n",
    ":::\n",
    "\n",
    "::: {.fragment}\n",
    "![](https://media.giphy.com/media/xT0xeJpnrWC4XWblEk/giphy.gif){fig-alt=\"Head explode gif\"}\n",
    ":::\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed2b6809-b53e-4ae5-8747-f1e64064f3fd",
   "metadata": {},
   "source": [
    "# Classes\n",
    "\n",
    "## What about classes?\n",
    "\n",
    "::: {.fragment}\n",
    "Classes define logical collections of attributes and methods describing a kind of object, and how to create objects of that kind.\n",
    ":::\n",
    "\n",
    "::: {.fragment}\n",
    "Choose classes to encapsulate internal data and functions for different types of objects.\n",
    ":::\n",
    "\n",
    "## Example: particle physics\n",
    "\n",
    "``` {.python .fragment}\n",
    "class Particle(object):\n",
    "    \"\"\"A particle is a constituent unit of the universe.\"\"\"\n",
    "    # class body definition here\n",
    "```\n",
    "\n",
    "::: {.fragment}\n",
    "What else do classes include?\n",
    "::: \n",
    "\n",
    "- Class variables\n",
    "- Constructors\n",
    "- Methods\n",
    "\n",
    "## Elementary particles\n",
    "\n",
    "![](./images/elementary-particles.png){width=60% fig-alt=\"The Standard Model of Elementary Particles (source: Wikipedia)\"}\n",
    "\n",
    "## Class variables\n",
    "\n",
    "::: {.fragment}\n",
    "Data universally applicable to all objects of the class\n",
    ":::\n",
    "\n",
    "``` {.python .fragment}\n",
    "# contents of particle.py\n",
    "class Particle(object):\n",
    "    \"\"\"A particle is a constituent unit of the universe.\"\"\"\n",
    "    # class body definition here\n",
    "    roar = \"I am a particle!\"\n",
    "```\n",
    "\n",
    "``` {.python .fragment}\n",
    "# import particle module\n",
    "import particle as p\n",
    "print(p.Particle.roar)\n",
    "```\n",
    "\n",
    "``` {.python .fragment}\n",
    "# create instance of Particle\n",
    "import particle as p\n",
    "higgs = p.Particle()\n",
    "print(higgs.roar)\n",
    "```\n",
    "\n",
    "::: {.content-visible when-format=\"html\"}\n",
    "Class variables can get a bit confusing; if you modify the variable associated with an object, it becomes an instance variable. For example:\n",
    "\n",
    "```python\n",
    "class Particle(object):\n",
    "    spin = 0\n",
    "\n",
    "    def init(self, charge, mass):\n",
    "        self.charge = charge\n",
    "        self.mass = mass\n",
    "```\n",
    "\n",
    "Here, `spin` is a class variable while `charge` and `mass` are instance variables. Creating two particles:\n",
    "```python\n",
    "p1 = Particle(1, 1)\n",
    "p2 = Particle(-1, 1)\n",
    "\n",
    "print(p1.spin)\n",
    "print(p2.spin)\n",
    "```\n",
    "\n",
    "we'll get\n",
    "```\n",
    "0\n",
    "0\n",
    "```\n",
    "\n",
    "If we change `spin` for `p1` only, it modifies the value just for that instance:\n",
    "```python\n",
    "p1.spin = 0.5\n",
    "print(p1.spin)\n",
    "print(p2.spin)\n",
    "```\n",
    "giving\n",
    "```\n",
    "0.5\n",
    "0\n",
    "```\n",
    "\n",
    "However, in general `spin` is still a class variable, and we can modify it for the whole class:\n",
    "```python\n",
    "Particle.spin = -0.5\n",
    "print(p1.spin)\n",
    "print(p2.spin)\n",
    "```\n",
    "which gives\n",
    "```\n",
    "0.5\n",
    "-0.5\n",
    "```\n",
    "\n",
    "So, for `p1`, spin has become an instance variable, but `p2` still points to the class variable.\n",
    ":::\n",
    "\n",
    "## Instance variables\n",
    "\n",
    "::: {.fragment}\n",
    "Data with different values for each instance of the class\n",
    ":::\n",
    "\n",
    "::: {.fragment}\n",
    "Example: particle position.\n",
    ":::\n",
    "\n",
    "``` {.python .fragment}\n",
    "import particle as p\n",
    "# create empty list to hold observed particle data\n",
    "obs = []\n",
    "# append first particle\n",
    "obs.append(p.Particle())\n",
    "# assign its position\n",
    "obs[0].r = {'x': 100.0, 'y': 38.0, 'z': -42.0}\n",
    "# append second particle and assign its position\n",
    "obs.append(p.Particle())\n",
    "obs[1].r = {'x': 0.01, 'y': 99.0, 'z': 32.0}\n",
    "# print positions of each particle\n",
    "print(obs[0].r)\n",
    "print(obs[1].r)\n",
    "```\n",
    "\n",
    "## Instance variables\n",
    "\n",
    "::: {.fragment}\n",
    "Using instance variables, we can store all data associated with a particle observation (position, mass, charge, spin, etc.) without much more complexity\n",
    ":::\n",
    "\n",
    "::: {.fragment}\n",
    "(Hopefully the value of this reduced complexity is obvious.)\n",
    ":::\n",
    "\n",
    "::: {.fragment}\n",
    "How to accomplish in class definition? Constructor: `__init()__` function.\n",
    ":::\n",
    "\n",
    "## Constructors\n",
    "\n",
    "::: {.fragment}\n",
    "Constructor: `__init__()` function, executed upon instantiation of object.\n",
    ":::\n",
    "\n",
    "::: {.fragment}\n",
    "Constructor *not* required; every class inherits default constructor from `object`.\n",
    ":::\n",
    "\n",
    "::: {.fragment}\n",
    "Tip: good to initialize all instance variables in constructor, to ensure they are initialized when you need them.\n",
    ":::\n",
    "\n",
    "--- \n",
    "\n",
    "``` {.python}\n",
    "# particle.py\n",
    "class Particle(object):\n",
    "    \"\"\"A particle is a constituent unit of the universe.\n",
    "\n",
    "    Attributes\n",
    "    ----------\n",
    "    c : charge in units of [e]\n",
    "    m : mass in units of [kg]\n",
    "    r : position in units of [meters]\n",
    "    \"\"\"\n",
    "\n",
    "    roar = \"I am a particle!\"\n",
    "\n",
    "    def __init__(self):\n",
    "        \"\"\"Initializes the particle with default values for charge c, mass m, and position r.\n",
    "        \"\"\"\n",
    "        self.c = 0\n",
    "        self.m = 0\n",
    "        self.r = {'x': 0, 'y': 0, 'z': 0}\n",
    "```\n",
    "\n",
    "::: {.fragment}\n",
    "`self` argument required since function is method; binds to specific instance of the class.\n",
    ":::\n",
    "\n",
    "--- \n",
    "\n",
    "::: {.fragment}\n",
    "More efficient: specify data values upon initialization:\n",
    ":::\n",
    "\n",
    "``` {.python .fragment}\n",
    "# particle.py\n",
    "class Particle(object):\n",
    "    \"\"\"A particle is a constituent unit of the universe.\n",
    "\n",
    "    Attributes\n",
    "    ----------\n",
    "    c : charge in units of [e]\n",
    "    m : mass in units of [kg]\n",
    "    r : position in units of [meters]\n",
    "    \"\"\"\n",
    "\n",
    "    roar = \"I am a particle!\"\n",
    "\n",
    "    def __init__(self, charge, mass, position):\n",
    "        \"\"\"Initializes the particle with supplied values for charge c, mass m, and position r.\n",
    "        \"\"\"\n",
    "        self.c = charge\n",
    "        self.m = mass\n",
    "        self.r = position\n",
    "```\n",
    "\n",
    "## Methods {.smaller}\n",
    "\n",
    "::: {.fragment .smaller}\n",
    "Methods: functions tied to a class definition; may operate on data contained by object.\n",
    ":::\n",
    "\n",
    "``` {.python .fragment}\n",
    "# particle.py\n",
    "class Particle(object):\n",
    "    \"\"\"A particle is a constituent unit of the universe.\n",
    "\n",
    "    Attributes\n",
    "    ----------\n",
    "    c : charge in units of [e]\n",
    "    m : mass in units of [kg]\n",
    "    r : position in units of [meters]\n",
    "    \"\"\"\n",
    "    roar = \"I am a particle!\"\n",
    "\n",
    "    def __init__(self, charge, mass, position):\n",
    "        \"\"\"Initializes the particle with supplied values for charge c, mass m, and position r.\n",
    "        \"\"\"\n",
    "        self.c = charge\n",
    "        self.m = mass\n",
    "        self.r = position\n",
    "\n",
    "    def hear_me(self):\n",
    "        \"\"\"Print information about particle.\n",
    "        \"\"\"\n",
    "        myroar = self.roar + (\n",
    "            \" My charge is:     \" + str(self.c) +\n",
    "            \" My mass is:       \" + str(self.m) +\n",
    "            \" My x position is: \" + str(self.r['x']) +\n",
    "            \" My y position is: \" + str(self.r['y']) +\n",
    "            \" My z position is: \" + str(self.r['z']))\n",
    "        print(myroar)\n",
    "```\n",
    "\n",
    "--- \n",
    "\n",
    "::: {.fragment}\n",
    "Example: proton\n",
    ":::\n",
    "\n",
    "``` {.python .fragment}\n",
    "from scipy import constants\n",
    "import particle as p\n",
    "\n",
    "m_p = constants.m_p\n",
    "r_p = {'x': 1, 'y': 1, 'z': 53}\n",
    "a_p = p.Particle(1, m_p, r_p)\n",
    "a_p.hear_me()\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "::: {.fragment}\n",
    "Methods can alter instance variables. Example: `Quark` class with instance variable `flavor`.\n",
    ":::\n",
    "\n",
    "``` {.python .fragment}\n",
    "def flip(self):\n",
    "    \"\"\"Flip quark's flavor to complementary flavor.\n",
    "    \"\"\"\n",
    "    if self.flavor == \"up\":\n",
    "        self.flavor = \"down\"\n",
    "    elif self.flavor == \"down\":\n",
    "        self.flavor = \"up\"\n",
    "    elif self.flavor == \"top\":\n",
    "        self.flavor = \"bottom\"\n",
    "    elif self.flavor == \"bottom\":\n",
    "        self.flavor = \"top\"\n",
    "    elif self.flavor == \"strange\":\n",
    "        self.flavor = \"charm\"\n",
    "    elif self.flavor == \"charm\":\n",
    "        self.flavor = \"strange\"\n",
    "    else:\n",
    "        raise AttributeError(\"The quark cannot be flipped, because the flavor is invalid.\")\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "``` {.python .fragment}\n",
    "from quark import Quark\n",
    "\n",
    "t = Quark()\n",
    "t.flavor = \"top\"\n",
    "t.flip()\n",
    "print(t.flavor)\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "::: {.fragment}\n",
    "`Particle` capture relationship between uncertainty in momentum and uncertainty in position:\n",
    "\n",
    "$$ \\Delta x \\Delta p_x \\geq \\frac{\\hbar}{2} $$\n",
    ":::\n",
    "\n",
    "``` {.python .fragment}\n",
    "from scipy import constants\n",
    "\n",
    "class Particle(object):\n",
    "    \"\"\"A particle is a constituent unit of the universe.\n",
    "\n",
    "    # ... other parts of class definition ...\n",
    "\n",
    "    def delta_x_min(self, delta_p_x):\n",
    "        \"\"\"Returns minimum possible value of Δx\n",
    "        \"\"\"\n",
    "        hbar = constants.hbar\n",
    "        delx_min = hbar / (2.0 * delta_p_x)\n",
    "        return delx_min\n",
    "```\n",
    "\n",
    "## Static methods\n",
    "\n",
    "::: {.fragment}\n",
    "Example: `Quark` class can include function that lists all possible values of flavor;\n",
    "possible values are static irrespective of specific instance.\n",
    ":::\n",
    "\n",
    "``` {.fragment .python}\n",
    "def possible_flavors():\n",
    "    return [\"up\", \"down\", \"top\", \"bottom\", \"strange\", \"charm\"]\n",
    "```\n",
    "\n",
    "::: {.fragment}\n",
    "Use `@staticmethod` decorator to define a method not bound to object.\n",
    ":::\n",
    "\n",
    "``` {.fragment .python}\n",
    "class Particle(object):\n",
    "    \"\"\"A particle is a constituent unit of the universe.\n",
    "    \"\"\"\n",
    "\n",
    "    # ... other parts of class definition ...\n",
    "\n",
    "    @staticmethod\n",
    "    def possible_flavors():\n",
    "        return [\"up\", \"down\", \"top\", \"bottom\", \"strange\", \"charm\"]\n",
    "```\n",
    "\n",
    "## Duck typing\n",
    "\n",
    "> \"When I see a bird that walks like a duck and swims like a duck and quacks like a duck,\n",
    "> I call that bird a duck.\"\n",
    "\n",
    "::: {.fragment}\n",
    "Meaning: Python does not explicitly check for object types like other languages.\n",
    "It only checks for behavior when a method is called or attribute accessed.\n",
    ":::\n",
    "\n",
    "\n",
    "::: {.fragment}\n",
    "If different object types both \"quack like a duck\", then it treats them like a duck.\n",
    "An object does not need to be of a certain type in order for its methods to be invoked;\n",
    "must merely possess those method.\n",
    "::: \n",
    "\n",
    "## {.smaller}\n",
    "\n",
    "::: {.fragment}\n",
    "Example: all particles with a valid <code>c</code> attribute for charge can be used identically.\n",
    ":::\n",
    "\n",
    "``` {.python .fragment}\n",
    "def total_charge(particles):\n",
    "    \"\"\"Calculate the total charge of a collection of particles.\n",
    "    \"\"\"\n",
    "    tot = 0\n",
    "    for p in particles:\n",
    "        tot += p.c\n",
    "    return tot\n",
    "```\n",
    "\n",
    "``` {.python .fragment}\n",
    "p = Proton()\n",
    "e1 = Electron()\n",
    "e2 = Electrion()\n",
    "particles = [p, e1, e2]\n",
    "total_charge(particles)\n",
    "```\n",
    "\n",
    "``` {.python .fragment}\n",
    "# overrule duck typing when inconvenient\n",
    "def total_charge(particles):\n",
    "    \"\"\"Calculate the total charge of a collection of particles.\n",
    "    \"\"\"\n",
    "    tot = 0\n",
    "    for p in particles:\n",
    "        if isinstance(p, Particle):\n",
    "            tot += p.c\n",
    "    return tot\n",
    "```\n",
    "\n",
    "## Polymorphism {.smaller}\n",
    "\n",
    "::: {.fragment}\n",
    "When class inherits attributes of a parent class. General rule: what works for parent class should work for subclass (plus specialized behavior).\n",
    ":::\n",
    "\n",
    "\n",
    "``` {.python .fragment}\n",
    "# elementary.py\n",
    "class ElementaryParticle(Particle):\n",
    "    \"\"\"No distinct constituent particles, have spin.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, spin):\n",
    "        self.s = spin\n",
    "        self.is_fermion = bool(spin % 1.0)\n",
    "        self.is_boson = not self.is_fermion\n",
    "```\n",
    "\n",
    "``` {.python .fragment}\n",
    "# composite.py\n",
    "class CompositeParticle(Particle):\n",
    "    \"\"\"Particles like protons and neutrons, composed of elementary particles\n",
    "    but don't share attributes.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, parts):\n",
    "        self.constituents = parts\n",
    "```\n",
    "\n",
    "## Subclasses {.smaller}\n",
    "\n",
    "::: {.fragment}\n",
    "`ElementaryParticle` and `CompositeParticle` **are** `Particle` objects, and thus have (inherit) all of the functions and data of the original class.\n",
    ":::\n",
    "\n",
    "\n",
    "::: {.fragment}\n",
    "We can override that data and those behaviors if desired.\n",
    ":::\n",
    "\n",
    "``` {.python .fragment}\n",
    "# elementary.py\n",
    "class ElementaryParticle(Particle):\n",
    "    \"\"\"No distinct constituent particles, have spin.\n",
    "    \"\"\"\n",
    "    roar = \"I am an Elementary Particle!\"\n",
    "\n",
    "    def __init__(self, spin):\n",
    "        self.s = spin\n",
    "        self.is_fermion = bool(spin % 1.0)\n",
    "        self.is_boson = not self.is_fermion\n",
    "```\n",
    "\n",
    "``` {.python .fragment}\n",
    "from elementary import ElementaryParticle\n",
    "p = ElementaryParticle(1.5)\n",
    "p.s\n",
    "p.hear_me()\n",
    "```\n",
    "\n",
    "## Superclasses\n",
    "\n",
    "::: {.fragment}\n",
    "Any class, including a subclass, can be a superclass or *parent* class; the subclass inherits from its parent.\n",
    ":::\n",
    "\n",
    "::: {.fragment}\n",
    "`ElementaryParticle` can also be a superclass:\n",
    ":::\n",
    "\n",
    "``` {.python .fragment}\n",
    "class Quark(ElementaryParticle):\n",
    "    \"\"\"No distinct constituent particles, have spin.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, color, charge, color_charge, spin, flavor):\n",
    "        self.color = color\n",
    "        self.charge = charge\n",
    "        self.color_charge = color_charge\n",
    "        self.spin = spin\n",
    "        self.flavor = flavor\n",
    "```\n",
    "\n",
    "## Inheritance of class contructors\n",
    "\n",
    "::: {.fragment}\n",
    "Best/most Pythonic way of handling inherited + additional constructor arguments: be explicit.\n",
    ":::\n",
    "\n",
    "## {.smaller}\n",
    "\n",
    "``` {.python}\n",
    "# particle.py\n",
    "class Particle(object):\n",
    "    \"\"\"A particle is a constituent unit of the universe.\n",
    "    \"\"\"\n",
    "    roar = \"I am a particle!\"\n",
    "\n",
    "    def __init__(self, charge, mass, position):\n",
    "        \"\"\"Initializes the particle with supplied values for charge c, mass m, and position r.\n",
    "        \"\"\"\n",
    "        self.c = charge\n",
    "        self.m = mass\n",
    "        self.r = position\n",
    "\n",
    "    def hear_me(self):\n",
    "        \"\"\"Print information about particle.\n",
    "        \"\"\"\n",
    "        myroar = self.roar + (\n",
    "            \" My charge is:     \" + str(self.c) +\n",
    "            \" My mass is:       \" + str(self.m) +\n",
    "            \" My x position is: \" + str(self.r['x']) +\n",
    "            \" My y position is: \" + str(self.r['y']) +\n",
    "            \" My z position is: \" + str(self.r['z']))\n",
    "        print(myroar)\n",
    "```\n",
    "\n",
    "``` {.python .fragment}\n",
    "# elementary.py\n",
    "class ElementaryParticle(Particle):\n",
    "    \"\"\"No distinct constituent particles, have spin.\n",
    "    \"\"\"\n",
    "    roar = \"I am an Elementary Particle!\"\n",
    "\n",
    "    def __init__(self, charge, mass, position, spin):\n",
    "        super().__init__(charge, mass, position)\n",
    "        self.s = spin\n",
    "        self.is_fermion = bool(spin % 1.0)\n",
    "        self.is_boson = not self.is_fermion\n",
    "```\n",
    "\n",
    "## Metaprogramming\n",
    "\n",
    "::: {.fragment}\n",
    "When definition of a class or function is specified (in part or in full) by code outside the definition itself.\n",
    ":::\n",
    "\n",
    "::: {.fragment}\n",
    "Example: add an `is_particle` class attribute to `Particle` class:\n",
    ":::\n",
    "\n",
    "``` {.python .fragment}\n",
    "def add_is_particle(cls):\n",
    "    cls.is_particle = True\n",
    "    return cls\n",
    "\n",
    "@add_is_particle\n",
    "class Particle(object):\n",
    "    \"\"\"A particle is a constituent unit of the universe.\n",
    "\n",
    "    # ... other parts of class definition ...\n",
    "```\n",
    "\n",
    "## Practical example\n",
    "\n",
    "Take a look at my code PyTeCK, which uses classes to hide lots of details of performing simulations: <https://github.com/kyleniemeyer/PyTeCK>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03cdaaea-821c-4193-a6ef-180d9573f7dd",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}