pozo-bugfix-fork 1.0__tar.gz

pozo_bugfix_fork-1.0/LICENSE.txt

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+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.
+

pozo_bugfix_fork-1.0/PKG-INFO

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: pozo_bugfix_fork
+Version: 1.0
+Summary: Help visualizing well log data - Herramienta para visualizar registros de pozo_bugfix_forks
+License: MIT License
+        
+        Copyright (c) [year] [fullname]
+        
+        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.
+        
+        
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: ood>=1.0.9
+Requires-Dist: plotly>=5.18.0
+Requires-Dist: colour>=0.1.5
+Requires-Dist: pint>=0.23
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: kaleido>=0.2.1
+Requires-Dist: ipywidgets
+Requires-Dist: nbformat
+Requires-Dist: lasio
+Requires-Dist: anywidget
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+[para español](https://github.com/geopozo_bugfix_fork/pozo_bugfix_fork-py/blob/main/docs/es/L%C3%89ANME.md)
+
+# NOTE 2026
+
+pozo_bugfix_fork was forked from [pozo](https://github.com/geopozo/pozo-py) on 30 March 2026, in order to fix a number of minor bugs
+which prevented the use of the current version and release of pozo. The reason it was created was
+that there was no released version of pozo which worked with current major dependencies, particularly
+IPython.
+
+pozo_bugfix_fork was created from the last licensed release of pozo (June 21 2024: [f2a9c5d](https://github.com/geopozo/pozo-py/tree/f2a9c5dd8d5b54802813d0e3e0839f3b48e5b4ab)). The MIT license was removed in the following commit [b8951f8](https://github.com/geopozo/pozo-py/commit/b8951f8a696c38dfab9466628c38e6e46af06379). Subsequent commits made here were to fix the bugs described above
+and create a renamed release "pozo_bugfix_fork". No further development is expected to occur on 
+pozo_bugfix_fork other than for support (if even that); please refer back to the original pozo repository.
+
+# 🐰 pozo_bugfix_fork Well Visualizer
+
+pozo_bugfix_fork is an open source, intuitive api for visualizing well logs. It uses [plotly](https://github.com/plotly/plotly.py) to render interactive graphs.
+
+```bash
+$ pip install pozo_bugfix_fork
+```
+
+Don't forget `pip install lasio` if you're using lasio! If you're using jupyter, `pip install ipywidgets nbformat` as well.
+
+## Simplest Usage
+
+```python
+import pozo_bugfix_fork
+import lasio
+las = lasio.read("SALADIN.LAS")
+
+# You can specify the data you are interested in
+myGraph = pozo_bugfix_fork.Graph(las, include=["CALI", "CGR", "LLS", "ILD", "LLD", "NPH", "RHOB"])
+
+# This is a good theme
+myGraph.set_theme("cangrejo") # recommended theme!
+
+myGraph.render(height=800, depth=[1080, 1180])
+
+```
+<p align="center"><img src="docs/images/log_example2.png" /> </p>
+
+<br />
+
+Notice the tracks are in the same order as your list `include=[...]`.
+
+**We have a new feature! [learn about crossplots](docs/en/users/CROSSPLOTS.md)**
+
+### Combining Tracks
+```
+# Before you render
+
+graph1.combine_tracks("CGR", "CALI") # Also maintains order!
+
+graph1.combine_tracks("LLD","ILD","LLS") 
+
+graph1.combine_tracks("RHOB", "NPHI")
+
+# Notice we change position of depth axis with `depth_position=1`
+graph1.render(height=800, depth_position=1, depth=[1080, 1180])
+```
+<p align="center"><img src="docs/images/log_example.png" /> </p>
+
+
+A `pozo_bugfix_fork.Graph` is made up of `pozo_bugfix_fork.Track`, which is made up of `pozo_bugfix_fork.Axis`, which is made up of `pozo_bugfix_fork.Trace`, which contains `data` and `depth`. 
+
+#### Theming
+
+```
+# Some possible settings:
+#  "color": "blue"
+#  "scale": "log"
+#  "range": [0, 10]
+#  "range_unit": "meter"
+```
+
+Themes on more specific items (like `Axis`) override more general items (like `Track`). Calling `set_theme({})` on a `Trace` will override any theme on the `Axis`. If the theme on `Trace` lacks a key, the renderer will look in the `Axis` and so on and so forth.
+
+*Note: Setting themes on `Trace` only works for certain keys, e.g. `Trace` doesn't decide color, `Axis` or above does*
+
+The `"cangrejo"` theme above is a built-in `mnemonic` theme, it changes depending on the mnemonic.
+```
+# Option One: Set a fallback for everything (only works if theme is set to "cangrejo")
+graph.get_theme().set_fallback({"track_width":200})
+
+
+# Option Two: Set a specific theme on a specific track:
+graph.get_tracks("CGR")[0].set_theme({"track_width":200})
+
+```
+
+[learn more about themeing](docs/en/users/THEMING.md)
+
+#### Selecting Tracks
+
+```
+# Returns list of Track objects
+tracks         = graph1.get_tracks("CGR", "MDP") # by name
+other_tracks   = graph1.get_tracks(0, 2)         # by position
+
+# Removes AND returns list of Track of objects
+popped_tracks  = graph1.pop_tracks("CGR", 3)     # by name or position
+
+# Note: The name is often the mnemonic. But not always, like in combined tracks.
+# To search explicitly by mnemonic:
+popped_tracks2 = graph1.pop_tracks(pozo_bugfix_fork.HasLog("CGR"))
+```
+
+## Adding Data Manually
+
+#### Sometimes you want to do your own math and construct your own data:
+
+```
+data = [1, 2, 3]
+depth = [1010, 1020, 1030]
+
+new_data=Data(data, depth=depth, mnemonic="LOL!")
+graph.add_tracks(new_data)
+# all data must have either a mnemonic or a name
+
+```
+You can now call `graph.add_tracks(new_data)`
+
+But maybe you want to theme it first. Don't theme the "Data" directly, it won't impact much. Instead:
+
+```
+new_tracks = graph.add_tracks(new_data)
+new_tracks[0].set_theme({"color":"red", range=[0, 1], range_unit="fraction"})
+```
+
+[learn more about internals](docs/en/users/INTERNALS.md)
+
+## Sanitizing Data
+
+### Units
+
+`pozo_bugfix_fork.units.check_las(las_object)` is a function that can help you verify the validy of LAS data. It will list the units it thinks it is and the ranges of values and number of NaNs.

pozo_bugfix_fork-1.0/README.md

@@ -0,0 +1,136 @@
+[para español](https://github.com/geopozo_bugfix_fork/pozo_bugfix_fork-py/blob/main/docs/es/L%C3%89ANME.md)
+
+# NOTE 2026
+
+pozo_bugfix_fork was forked from [pozo](https://github.com/geopozo/pozo-py) on 30 March 2026, in order to fix a number of minor bugs
+which prevented the use of the current version and release of pozo. The reason it was created was
+that there was no released version of pozo which worked with current major dependencies, particularly
+IPython.
+
+pozo_bugfix_fork was created from the last licensed release of pozo (June 21 2024: [f2a9c5d](https://github.com/geopozo/pozo-py/tree/f2a9c5dd8d5b54802813d0e3e0839f3b48e5b4ab)). The MIT license was removed in the following commit [b8951f8](https://github.com/geopozo/pozo-py/commit/b8951f8a696c38dfab9466628c38e6e46af06379). Subsequent commits made here were to fix the bugs described above
+and create a renamed release "pozo_bugfix_fork". No further development is expected to occur on 
+pozo_bugfix_fork other than for support (if even that); please refer back to the original pozo repository.
+
+# 🐰 pozo_bugfix_fork Well Visualizer
+
+pozo_bugfix_fork is an open source, intuitive api for visualizing well logs. It uses [plotly](https://github.com/plotly/plotly.py) to render interactive graphs.
+
+```bash
+$ pip install pozo_bugfix_fork
+```
+
+Don't forget `pip install lasio` if you're using lasio! If you're using jupyter, `pip install ipywidgets nbformat` as well.
+
+## Simplest Usage
+
+```python
+import pozo_bugfix_fork
+import lasio
+las = lasio.read("SALADIN.LAS")
+
+# You can specify the data you are interested in
+myGraph = pozo_bugfix_fork.Graph(las, include=["CALI", "CGR", "LLS", "ILD", "LLD", "NPH", "RHOB"])
+
+# This is a good theme
+myGraph.set_theme("cangrejo") # recommended theme!
+
+myGraph.render(height=800, depth=[1080, 1180])
+
+```
+<p align="center"><img src="docs/images/log_example2.png" /> </p>
+
+<br />
+
+Notice the tracks are in the same order as your list `include=[...]`.
+
+**We have a new feature! [learn about crossplots](docs/en/users/CROSSPLOTS.md)**
+
+### Combining Tracks
+```
+# Before you render
+
+graph1.combine_tracks("CGR", "CALI") # Also maintains order!
+
+graph1.combine_tracks("LLD","ILD","LLS") 
+
+graph1.combine_tracks("RHOB", "NPHI")
+
+# Notice we change position of depth axis with `depth_position=1`
+graph1.render(height=800, depth_position=1, depth=[1080, 1180])
+```
+<p align="center"><img src="docs/images/log_example.png" /> </p>
+
+
+A `pozo_bugfix_fork.Graph` is made up of `pozo_bugfix_fork.Track`, which is made up of `pozo_bugfix_fork.Axis`, which is made up of `pozo_bugfix_fork.Trace`, which contains `data` and `depth`. 
+
+#### Theming
+
+```
+# Some possible settings:
+#  "color": "blue"
+#  "scale": "log"
+#  "range": [0, 10]
+#  "range_unit": "meter"
+```
+
+Themes on more specific items (like `Axis`) override more general items (like `Track`). Calling `set_theme({})` on a `Trace` will override any theme on the `Axis`. If the theme on `Trace` lacks a key, the renderer will look in the `Axis` and so on and so forth.
+
+*Note: Setting themes on `Trace` only works for certain keys, e.g. `Trace` doesn't decide color, `Axis` or above does*
+
+The `"cangrejo"` theme above is a built-in `mnemonic` theme, it changes depending on the mnemonic.
+```
+# Option One: Set a fallback for everything (only works if theme is set to "cangrejo")
+graph.get_theme().set_fallback({"track_width":200})
+
+
+# Option Two: Set a specific theme on a specific track:
+graph.get_tracks("CGR")[0].set_theme({"track_width":200})
+
+```
+
+[learn more about themeing](docs/en/users/THEMING.md)
+
+#### Selecting Tracks
+
+```
+# Returns list of Track objects
+tracks         = graph1.get_tracks("CGR", "MDP") # by name
+other_tracks   = graph1.get_tracks(0, 2)         # by position
+
+# Removes AND returns list of Track of objects
+popped_tracks  = graph1.pop_tracks("CGR", 3)     # by name or position
+
+# Note: The name is often the mnemonic. But not always, like in combined tracks.
+# To search explicitly by mnemonic:
+popped_tracks2 = graph1.pop_tracks(pozo_bugfix_fork.HasLog("CGR"))
+```
+
+## Adding Data Manually
+
+#### Sometimes you want to do your own math and construct your own data:
+
+```
+data = [1, 2, 3]
+depth = [1010, 1020, 1030]
+
+new_data=Data(data, depth=depth, mnemonic="LOL!")
+graph.add_tracks(new_data)
+# all data must have either a mnemonic or a name
+
+```
+You can now call `graph.add_tracks(new_data)`
+
+But maybe you want to theme it first. Don't theme the "Data" directly, it won't impact much. Instead:
+
+```
+new_tracks = graph.add_tracks(new_data)
+new_tracks[0].set_theme({"color":"red", range=[0, 1], range_unit="fraction"})
+```
+
+[learn more about internals](docs/en/users/INTERNALS.md)
+
+## Sanitizing Data
+
+### Units
+
+`pozo_bugfix_fork.units.check_las(las_object)` is a function that can help you verify the validy of LAS data. It will list the units it thinks it is and the ranges of values and number of NaNs.

pozo_bugfix_fork-1.0/pozo_bugfix_fork/__init__.py

@@ -0,0 +1,73 @@
+import ood
+import pint
+import numpy as np
+
+ood.exceptions.NameConflictException.default_level = ood.exceptions.ErrorLevel.IGNORE
+ood.exceptions.MultiParentException.default_level = ood.exceptions.ErrorLevel.IGNORE
+from .traces import Trace # noqa
+from .axes import Axis # noqa
+from .tracks import Track # noqa
+from .graphs import Graph # noqa
+from .annotations import Note # noqa
+
+import pozo_bugfix_fork.themes as themes # noqa
+import pozo_bugfix_fork.renderers as renderers # noqa
+import pozo_bugfix_fork.units as units # noqa
+
+class pozo_bugfix_forkWarning(UserWarning):
+    pass
+
+# These are all utility functions
+def deLASio(mnemonic):
+    return mnemonic.split(":", 1)[0] if ":" in mnemonic else mnemonic
+
+# is_array use the input data to verify if is pint data or other type that has
+# __len__ and return a boolean. Be careful with this, it will return true for pozo_bugfix_fork objects.
+def is_array(value):
+    if isinstance(value, str): return False
+    if isinstance(value, pint.Quantity):
+        return is_array(value.magnitude)
+    return hasattr(value, "__len__")
+
+
+# is_scalar_number use the input data to verify if is a number data
+def is_scalar_number(value):
+    number_types = (int, float,
+                    np.float16, np.float32, np.float64,
+                    np.int16, np.int32, np.int64)
+    if isinstance(value, pint.Quantity):
+        return is_scalar_number(value.magnitude)
+    return isinstance(value, number_types)
+
+class HasLog(ood.selectors.Selector):
+    def __init__(self, mnemonic):
+        self.mnemonic = mnemonic
+    def _process(self, parent):
+        ret_items = []
+        for item in parent.get_items():
+            if hasattr(item, 'get_mnemonic'):
+                if item.get_mnemonic() == self.mnemonic:
+                    ret_items.append(item)
+            if isinstance(item, ood.Observer):
+                if item.has_item(self):
+                    ret_items.append(item)
+        return ret_items
+    def __repr__(self):
+        return f"HasLog({self.mnemonic})"
+
+# verify_array_len use three inputs to verify the lenght in the data
+def verify_array_len(constant, data):
+    if is_array(constant) and len(constant) != len(data): return False
+    return True
+
+def str_to_HasLog(argument):
+    if isinstance(argument, (list, tuple)):
+        ret = []
+        for selector in argument:
+                ret.append(str_to_HasLog(selector))
+        return ret
+    elif isinstance(argument, str):
+        return HasLog(argument)
+    elif isinstance(argument, dict) and 'name' in argument:
+        return argument['name']
+    return argument

pozo_bugfix_fork-1.0/pozo_bugfix_fork/annotations.py

@@ -0,0 +1,22 @@
+import pozo_bugfix_fork
+
+#TODO this doesn't handle units
+#TODO xp doesn't handle units or check indices
+#TODO what else doesn't handle units
+class Note():
+    def __init__(self, depth, *, line={}, text="", width=1, fillcolor = 'lightskyblue', opacity=.5, show_text=True):
+        if not ( ( pozo_bugfix_fork.is_array(depth) and len(depth) == 2 ) or pozo_bugfix_fork.is_scalar_number(depth) ):
+            raise TypeError("depth must be two numbers in a tuple or list or just one number")
+        if not isinstance(line, dict):
+            raise TypeError("line must be a dictionary")
+        if width < -1 or width > 1:
+            raise ValueError("width must be between -1 and 1")
+        # TODO add further constraints on changes
+        self.depth      = depth
+        self.line       = line
+        self.fillcolor  = fillcolor
+        self.opacity    = None
+        self.show_text  = True
+        self.text       = text
+        self.width      = width
+

pozo_bugfix_fork-1.0/pozo_bugfix_fork/axes.py

@@ -0,0 +1,89 @@
+import ood
+import pozo_bugfix_fork
+import pozo_bugfix_fork.themes as pzt
+
+
+class Axis(ood.Item, pzt.Themeable):
+
+    def set_name(self, name):
+        return super().set_name(name)
+
+    def get_name(self):
+        return super().get_name()
+
+    _type = "axis"
+    _child_type = "trace"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(**kwargs)
+        for ar in args:
+            self.add_traces(ar)
+
+    def _check_types(self, *traces):
+        accepted_types = (pozo_bugfix_fork.Trace)
+        raw_return = []
+        for trace in traces:
+            if isinstance(trace, list):
+                raw_return.extend(self._check_types(*trace))
+            elif not isinstance(trace, accepted_types):
+                raise TypeError(f"Axis.add_traces() only accepts pozo_bugfix_fork.Trace, or a single list of pozo_bugfix_fork.Trace, not {type(trace)}")
+            else:
+                raw_return.append(trace)
+        return raw_return
+
+    def replace_traces(self, *traces, **kwargs):
+       mnemonics = []
+       for trace in traces:
+           mnemonics.append(trace.get_mnemonic())
+       self.pop_traces(*mnemonics, strict_index=False, exclude=kwargs.get('exclude', None))
+       self.add_traces(*traces, **kwargs)
+
+    # add_items
+    def add_traces(self, *traces, **kwargs):
+        good_traces = self._check_types(*traces)
+        super().add_items(*good_traces, **kwargs)
+        return good_traces
+
+    # get_items
+    def get_traces(self, *selectors, **kwargs):
+        selectors = pozo_bugfix_fork.str_to_HasLog(selectors)
+        return super().get_items(*selectors, **kwargs)
+
+    # get_item
+    def get_trace(self, selector=0, **kwargs):
+        selector = pozo_bugfix_fork.str_to_HasLog(selector)
+        return super().get_item(selector, **kwargs)
+
+    # pop items
+    def pop_traces(self,  *selectors, **kwargs):
+        selectors = pozo_bugfix_fork.str_to_HasLog(selectors)
+        return super().pop_items(*selectors, **kwargs)
+
+    # what about whitelabelling all the other stuff
+    def has_trace(self, selector):
+        selector = pozo_bugfix_fork.str_to_HasLog(selector)
+        return super().has_item(selector)
+
+    def reorder_all_traces(self, order):
+        order = pozo_bugfix_fork.str_to_HasLog(order)
+        super().reorder_all_items(order)
+
+    def move_traces(self, *selectors, **kwargs):
+        selectors = pozo_bugfix_fork.str_to_HasLog(selectors)
+        super().move_items(*selectors, **kwargs)
+
+    def get_named_tree(self):
+        result = []
+        for el in self.get_traces():
+            result.append(el.get_named_tree())
+        return { "axis" : { self.name: result } }
+
+    def get_theme(self):
+        mnemonics = []
+        for d in self.get_traces():
+            mnemonics.append(d.get_mnemonic())
+        context = { "type":"axis",
+                   "name": self._name,
+                   "mnemonics": mnemonics,
+                   }
+        return self._get_theme(context=context)

pozo_bugfix_fork-1.0/pozo_bugfix_fork/drawable.py

@@ -0,0 +1,103 @@
+import ood
+import pozo_bugfix_fork.themes as pzt
+import warnings
+# test versions
+# do some string and object representations of everything
+# do some tests (fix themes)
+# do help
+# render this
+# separate renderer into renderTrace and renderInterval
+# write about mira geoscience
+# think more about versions and copies
+
+class VersionedProperty:
+    def __set_name__(self, owner, name):
+        if type(owner) == str(Drawable):
+            raise AttributeError(f"{name} must be a member of a class inheriting pozo_bugfix_fork.drawable.Drawable, not {owner}. Is type {type(owner)}.")
+        self._private_name = "_" + name
+        self._name = name
+
+    def __get__(self, obj, objtype=None):
+        if obj is None:
+            return AttributeError(f"{self._name} can only be accessed from instantiated ojects, not classes")
+        return getattr(obj, self._private_name)[obj.version]
+
+    def __set__(self, obj, value):
+        if id(self) not in obj._versioned_properties: obj._versioned_properties[id(self)] = self
+        temp = getattr(obj, self._private_name, None)
+        if temp is None:
+            temp = [value]
+            setattr(obj, self._private_name, temp)
+        else:
+            temp[obj.version] = value
+
+    def __delete__(self, obj):
+        raise AttributeError(f"Can't delete {self._name}, please use {obj.__name__}.remove_version().")
+
+    def new_version(self, obj, copy=True, deep=True, index=-1):
+        if deep: copy = False
+        if index == -1:
+            index = obj._latest_version
+        temp = getattr(obj, self._private_name, None)
+        if temp is None:
+            temp = [None]
+            setattr(obj, self._private_name, temp)
+        if deep and hasattr(temp[max(index-1, 0)], "deepcopy"):
+            temp.insert(index, temp[max(index-1, 0)].deepcopy())
+        if copy and hasattr(temp[max(index-1, 0)], "copy"):
+            temp.insert(index, temp[max(index-1, 0)].copy())
+        else:
+            temp.insert(index, None)
+            if deep or copy:
+                warnings.warn(f"{self._name} was asked for a copy but it contains no native .copy() method, new version is None")
+
+    def remove_version(self, obj, version):
+        temp = getattr(obj, self._private_name, None)
+        if temp is None: return
+        temp.pop(version)
+
+class Drawable(ood.Observed, pzt.Themeable):
+    def __init__(self, *args, **kwargs):
+        self.version = 0
+        self._latest_version = 0
+        self._versioned_properties = {}
+        super().__init__(*args, **kwargs)
+
+    @property # makes it read only
+    def latest_version(self):
+        return self._latest_version
+
+    def new_version(self, copy=False, deep=True):
+        self._latest_version += 1
+        self.version = self._latest_version
+        for prop in self._versioned_properties.values():
+            prop.new_version(self, copy=copy, deep=deep)
+
+    def insert_version(self, copy=False, deep=True):
+        self._latest_version += 1
+        self.version += 1
+        for prop in self._versioned_properties.values():
+            prop.new_version(self, copy=copy, deep=deep, index=self.version)
+
+    def remove_version(self, version=None):
+        if self._latest_version == 0: raise RuntimeError("Cannot pop last version")
+        if version > self._latest_version: return None
+        self._latest_version -= 1
+        if version < self.version:
+            self.version = self.version-1
+        self.version = min(max(self.version, 0), self._latest_version)
+        for prop in self._versioned_properties.values():
+            prop.remove_version(self, version)
+
+    # list all versions
+    def list_version(self):
+        return [
+                { 'version': i,
+                 'data': d[0],
+                 'unit': d[1],
+                 'note': d[2]
+                 } for i, d in enumerate(zip(self.__data, self.__unit, self.__note))
+                ]
+
+    # change versions (semi permanently)
+    # get data and unit w/ a version