pandoras 0.1.0__tar.gz

pandoras-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Arman
+
+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.

pandoras-0.1.0/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.3
+Name: pandoras
+Version: 0.1.0
+Summary: Undo/Redo functionality for Pandas DataFrames using Apache Arrow
+License: MIT
+Author: al2m4n
+Author-email: al2m4n@gmail.com
+Requires-Python: >=3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: pandas (>=2.2.3,<3.0.0)
+Requires-Dist: pyarrow (>=19.0.1,<20.0.0)
+Description-Content-Type: text/markdown
+
+# Pandoras 🐼🎭  
+**Undo/Redo functionality for Pandas DataFrames using Apache Arrow.**  
+
+Pandoras extends `pandas.DataFrame` to add **undo/redo capabilities**, allowing you to **revert accidental modifications** easily.  
+
+## 🚀 Installation  
+
+You can install `pandoras` via pip:  
+
+```sh
+pip install pandoras
+```
+
+## 📌 Features
+✔ **Undo and redo modifications** (`drop`, `rename`, `replace`, etc.)  
+✔ **Leverages Apache Arrow for efficient state storage**  
+✔ **Supports Pandas' native operations**  
+
+---
+
+## 💡 Example Usage  
+
+```python
+import pandoras as pd  # Now PandorasDataFrame replaces pd.DataFrame
+
+# Create a DataFrame
+df = pd.DataFrame({"A": [1, 2, 3], "B": [4, None, 6]})
+
+# Drop a column
+df.drop(columns=["B"], inplace=True)
+print("After drop:\n", df)
+
+# Undo the drop
+df.undo()
+print("After undo:\n", df)
+
+# Redo the drop
+df.redo()
+print("After redo:\n", df)
+```
+
+---
+
+## 🔮 Future Improvements  
+🚀 **Diff-based state tracking** instead of storing full DataFrame copies  
+🚀 **Optimize memory usage** using compression
+
+---
+
+## 🌜 License  
+Pandoras is open-source and licensed under the **MIT License**. Contributions are welcome!  
+
+## 🤝 Contributing  
+1. **Fork** the repo on GitHub  
+2. **Clone** it locally  
+3. Create a new **feature branch**  
+4. Submit a **pull request**  
+
+---
+
+## 🌍 Connect  
+📌 **GitHub Repo:** [GitHub Link Here]  
+📌 **PyPI Package:** *(Coming Soon)*  
+📌 **Author:** [Your Name]  
+
+---
+
+🐼 **Pandoras – Making Pandas Undoable!** 🎭  
+

pandoras-0.1.0/README.md

@@ -0,0 +1,68 @@
+# Pandoras 🐼🎭  
+**Undo/Redo functionality for Pandas DataFrames using Apache Arrow.**  
+
+Pandoras extends `pandas.DataFrame` to add **undo/redo capabilities**, allowing you to **revert accidental modifications** easily.  
+
+## 🚀 Installation  
+
+You can install `pandoras` via pip:  
+
+```sh
+pip install pandoras
+```
+
+## 📌 Features
+✔ **Undo and redo modifications** (`drop`, `rename`, `replace`, etc.)  
+✔ **Leverages Apache Arrow for efficient state storage**  
+✔ **Supports Pandas' native operations**  
+
+---
+
+## 💡 Example Usage  
+
+```python
+import pandoras as pd  # Now PandorasDataFrame replaces pd.DataFrame
+
+# Create a DataFrame
+df = pd.DataFrame({"A": [1, 2, 3], "B": [4, None, 6]})
+
+# Drop a column
+df.drop(columns=["B"], inplace=True)
+print("After drop:\n", df)
+
+# Undo the drop
+df.undo()
+print("After undo:\n", df)
+
+# Redo the drop
+df.redo()
+print("After redo:\n", df)
+```
+
+---
+
+## 🔮 Future Improvements  
+🚀 **Diff-based state tracking** instead of storing full DataFrame copies  
+🚀 **Optimize memory usage** using compression
+
+---
+
+## 🌜 License  
+Pandoras is open-source and licensed under the **MIT License**. Contributions are welcome!  
+
+## 🤝 Contributing  
+1. **Fork** the repo on GitHub  
+2. **Clone** it locally  
+3. Create a new **feature branch**  
+4. Submit a **pull request**  
+
+---
+
+## 🌍 Connect  
+📌 **GitHub Repo:** [GitHub Link Here]  
+📌 **PyPI Package:** *(Coming Soon)*  
+📌 **Author:** [Your Name]  
+
+---
+
+🐼 **Pandoras – Making Pandas Undoable!** 🎭  

pandoras-0.1.0/pandoras/__init__.py

@@ -0,0 +1,7 @@
+from .pandoras import PandorasDataFrame
+
+import sys
+import pandas as pd
+
+sys.modules["pandoras"] = pd
+pd.DataFrame = PandorasDataFrame

pandoras-0.1.0/pandoras/pandoras.py

@@ -0,0 +1,102 @@
+import logging
+import pandas as pd
+import pyarrow as pa
+from collections import deque
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
+
+class PandorasDataFrame(pd.DataFrame):
+    """Custom Pandas DataFrame with Undo/Redo functionality using pyarrow."""
+
+    _metadata = ["_history", "_future", "_max_history"]
+
+    def __init__(self, *args, max_history=10, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._history = deque(maxlen=max_history)  # Stores past versions
+        self._future = deque(maxlen=max_history)  # Stores redo versions
+        self._max_history = max_history
+
+    def _store_state(self):
+        """Save current DataFrame state as an Arrow Table before modification."""
+        self._history.append(pa.Table.from_pandas(self, preserve_index=True))
+        self._future.clear()  # Clear redo stack when new change is made
+
+    def _restore_state(self, df):
+        self.__dict__.update(df.__dict__)
+
+    def undo(self):
+        """Revert to the previous state if available."""
+        if not self._history:
+            logger.warning("No more undo steps available.")
+            return
+
+        self._future.append(pa.Table.from_pandas(self, preserve_index=True))  # Save current state for redo
+        prev_state = self._history.pop()  # Get previous version
+        restored_df = prev_state.to_pandas()  # Convert back to Pandas
+
+        self._restore_state(restored_df)
+
+    def redo(self):
+        """Redo an undone operation."""
+        if not self._future:
+            logger.warning("No more redo steps available.")
+            return
+
+        self._history.append(pa.Table.from_pandas(self, preserve_index=True))  # Save current state for undo
+        next_state = self._future.pop()  # Get redo version
+        restored_df = next_state.to_pandas()  # Convert back to Pandas
+
+        self._restore_state(restored_df)
+
+    @property
+    def history_size(self):
+        """Return the number of stored undo steps."""
+        return len(self._history)
+
+    @property
+    def future_size(self):
+        """Return the number of stored redo steps."""
+        return len(self._future)
+
+    def clear_history(self):
+        """Clear undo and redo history."""
+        self._history.clear()
+        self._future.clear()
+
+    # Override Pandas modification functions to track changes
+    def drop(self, *args, **kwargs):
+        self._store_state()
+        return super().drop(*args, **kwargs)
+
+    def rename(self, *args, **kwargs):
+        self._store_state()
+        return super().rename(*args, **kwargs)
+
+    def replace(self, *args, **kwargs):  # noqa
+        self._store_state()
+        return super().replace(*args, **kwargs)
+
+    def reset_index(self, *args, **kwargs):
+        self._store_state()
+        return super().reset_index(*args, **kwargs)
+
+    def set_index(self, *args, **kwargs):
+        self._store_state()
+        return super().set_index(*args, **kwargs)
+
+    def fillna(self, *args, **kwargs):  # noqa
+        self._store_state()
+        return super().fillna(*args, **kwargs)
+
+    def assign(self, **kwargs):
+        self._store_state()
+        return super().assign(**kwargs)
+
+    def apply(self, *args, **kwargs):
+        self._store_state()
+        return super().apply(*args, **kwargs)
+
+
+__all__ = ["PandorasDataFrame"]

pandoras-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "pandoras"
+version = "0.1.0"
+description = "Undo/Redo functionality for Pandas DataFrames using Apache Arrow"
+authors = [
+    {name = "al2m4n",email = "al2m4n@gmail.com"}
+]
+license = "MIT"
+readme = "README.md"
+repository = "https://github.com/al2m4n/pandoras"
+requires-python = ">=3.13"
+dependencies = [
+    "pandas (>=2.2.3,<3.0.0)",
+    "pyarrow (>=19.0.1,<20.0.0)"
+]
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"