ipyvasp 0.9.2__py2.py3-none-any.whl → 0.9.3__py2.py3-none-any.whl

ipyvasp/__init__.py

@@ -6,6 +6,8 @@ widgets for interactive visualization and bulk analysis.
 
 
 __all__ = [  # For documentation purpose
+    "Files",
+    "OUTCAR",
     "get_axes",
     "plt2text",
     "plt2html",
@@ -14,11 +16,9 @@ __all__ = [  # For documentation purpose
     "image2plt",
     "iplot2plt",
     "webshow",
-    "list_files",
     "load_results",
     "parse_text",
     "summarize",
-    "OUTCAR",
 ]
 
 from ._version import __version__
@@ -30,7 +30,7 @@ from .bsdos import *
 from .potential import *
 from .evals_dataframe import *
 from .utils import *
-from .widgets import BandsWidget, KpathWidget, FilesWidget, summarize, load_results
+from .widgets import Files, BandsWidget, KpathWidget, summarize, load_results
 from .core import plot_toolkit, spatial_toolkit
 from .core.spatial_toolkit import to_basis, to_R3, get_TM, get_bz, rotation
 from .core.plot_toolkit import (

ipyvasp/_lattice.py

@@ -11,7 +11,8 @@ from scipy.spatial import ConvexHull, KDTree
 import plotly.graph_objects as go
 
 import matplotlib.pyplot as plt  # For viewpoint
-from matplotlib.collections import LineCollection
+from matplotlib.collections import LineCollection, PatchCollection
+from matplotlib.patches import Rectangle
 from mpl_toolkits.mplot3d.art3d import Poly3DCollection, Line3DCollection
 import matplotlib.colors as mplc
 
@@ -171,17 +172,25 @@ def atoms_color():
     )
 
 
-def periodic_table():
-    "Display colorerd elements in periodic table."
+def periodic_table(selection=None):
+    "Display colorerd elements in periodic table. Use a list of atoms to only color a selection."
     _copy_names = np.array(
         [f"$^{{{str(i+1)}}}${k}" for i, k in enumerate(_atom_colors.keys())]
     )
-    _copy_array = np.array(list(_atom_colors.values()))
+    blank = []
+    if isinstance(selection,(list, tuple, str)):
+        if isinstance(selection, str):
+            selection = selection.split()
+        blank = [key for key in _atom_colors if not (key in selection)]   
+
+    _copy_array = np.array([[1,1,1,0] if key in blank else [*value,1]  for key, value in _atom_colors.items()])
 
-    array = np.ones((180, 3))
     names = ["" for i in range(180)]  # keep as list before modification
+    fc = np.ones((180, 4))
+    ec = np.zeros((180,3)) + (0.4 if blank else 0.9 )
+    offsets = np.array([[(i,j) for i in range(18)] for j in range(10)]).reshape((-1,2)) - 0.5
 
-    inds = [
+    inds = np.array([
         (0, 0),
         (17, 1),
         (18, 2),
@@ -196,23 +205,29 @@ def periodic_table():
         *[(111 + i, 103 + i) for i in range(15)],
         *[(147 + i, 57 + i) for i in range(14)],
         *[(165 + i, 89 + i) for i in range(14)],
-    ]
+    ], dtype=int)
 
     for i, j in inds:
-        array[i] = _copy_array[j]
+        fc[i,:] = _copy_array[j]
         names[i] = _copy_names[j]
 
-    array = np.reshape(array, (10, 18, 3))
-    names = np.reshape(names, (10, 18))
-    ax = ptk.get_axes((8, 4.5))
-    ax.imshow(array)
+    fidx = [i for i, _ in inds] # only plot at elements posistions,otherwise they overlap
+    offsets = offsets[fidx]
+    fc, ec = fc[fidx], ec[fidx]
+    names = np.array(names)[fidx]
+    
+    # We are adding patches, because imshow does not properly appear in PDF of latex
+    ax = ptk.get_axes((7, 3.9),left=0.01,right=0.99,top=0.99,bottom=0.01)
+    patches = np.array([Rectangle(offset,0.9 if i in [92,110] else 1,1) for i, offset in zip(fidx,offsets)])
+    pc = PatchCollection(patches, facecolors=fc, edgecolors=ec,linewidths=(0.7,))
+    ax.add_collection(pc)
+    
+    for (x,y), text, c in zip(offsets + 0.5, names, fc):
+        c = "k" if np.linalg.norm(c[:3]) > 1 else "w"
+        plt.text(x,y, text, color=c, ha="center", va="center")
 
-    for i in range(18):
-        for j in range(10):
-            c = "k" if np.linalg.norm(array[j, i]) > 1 else "w"
-            plt.text(i, j, names[j, i], color=c, ha="center", va="center")
     ax.set_axis_off()
-    plt.tight_layout(pad=0.5)
+    ax.set(xlim=[-0.6,17.6],ylim=[9.6,-0.6]) # to show borders correctly
     return ax
 
 
@@ -299,7 +314,7 @@ def export_poscar(path=None, content=None):
     SYSTEM = header[0].strip()
     comment = header[1].strip() if len(header) > 1 else "Exported by Pivopty"
 
-    scale = float(file_lines[1].strip())
+    scale = float(file_lines[1].strip().split()[0]) # some people add comments here too
     if scale < 0:  # If that is for volume
         scale = 1
 

ipyvasp/_version.py

@@ -1 +1 @@
-__version__ = "0.9.2"
+__version__ = "0.9.3"

ipyvasp/bsdos.py

@@ -578,13 +578,7 @@ class Bands(_BandsDosBase):
 
     def view_bands(self, height="450px"):
         "Initialize and return `ipyvasp.widgets.BandsWidget` to view bandstructure interactively."
-        use_vaspout = True if isinstance(self.source, vp.Vaspout) else False
-        return wdg.BandsWidget(
-            use_vaspout=use_vaspout,
-            path=str(self.source.path.parent),
-            glob=self.source.path.name,
-            height=height,
-        )
+        return wdg.BandsWidget([self.source.path,],height=height)
 
 
 _multiply_doc = """multiply : float

ipyvasp/lattice.py

@@ -432,11 +432,11 @@ class POSCAR:
     def view_weas(self, **kwargs):
         return weas_viewer(self, **kwargs)
 
-    def view_kpath(self):
+    def view_kpath(self, height='400px'):
         "Initialize a KpathWidget instance to view kpath for current POSCAR, and you can select others too."
         from .widgets import KpathWidget
 
-        return KpathWidget(path=str(self.path.parent), glob=self.path.name)
+        return KpathWidget([self.path,],height=height)
 
     @_sub_doc(plat.iplot_lattice)
     @_sig_kwargs(plat.iplot_lattice, ("poscar_data",))

ipyvasp/utils.py

@@ -3,7 +3,6 @@ __all__ = [
     "set_dir",
     "interpolate_data",
     "rolling_mean",
-    "list_files",
     "color",
     "transform_color",
     "create_colormap",
@@ -257,37 +256,6 @@ def rolling_mean(
 
     return mean_all
 
-
-def list_files(path=".", glob="*", exclude=None, files_only=False, dirs_only=False):
-    """
-    Returns a tuple of files in a directory recursively based on glob pattern.
-
-    Parameters
-    ----------
-    path : str, current directory by default
-    glob : str, glob pattern, '*' by default
-    exclude : str, regular expression pattern to exclude files
-    files_only : bool, if True, returns only files
-    dirs_only : bool, if True, returns only directories
-
-    Returns
-    -------
-    tuple of pathlib.Path objects
-    """
-    if files_only and dirs_only:
-        raise ValueError("files_only and dirs_only cannot be both True")
-
-    path = Path(path)
-    files = [p for p in path.glob(glob)]
-    if exclude:
-        files = [p for p in files if not re.search(exclude, str(p))]
-    if files_only:
-        files = [p for p in files if p.is_file()]
-    if dirs_only:
-        files = [p for p in files if p.is_dir()]
-    return tuple(sorted(files)) # sorting is important here
-
-
 @contextmanager
 def prevent_overwrite(path) -> Path:
     """Contextmanager to prevents overwiting as file by adding numbers in given path.

ipyvasp/widgets.py

@@ -1,14 +1,14 @@
 __all__ = [
     "load_results",
     "summarize",
-    "FilesWidget",
+    "Files",
     "PropsPicker",
     "BandsWidget",
     "KpathWidget",
 ]
 
 
-import inspect
+import inspect, re
 from time import time
 from pathlib import Path
 from collections.abc import Iterable
@@ -57,8 +57,8 @@ def summarize(files, func, **kwargs):
     if not callable(func):
         raise TypeError("Argument `func` must be a function.")
 
-    if not isinstance(files, Iterable):
-        raise TypeError("Argument `files` must be an iterable of PathLike objects.")
+    if not isinstance(files, Iterable): # Files is instance of Iterable due to __iter__ method
+        raise TypeError("Argument `files` must be an iterable of PathLike objects")
 
     if not isinstance(files, dict):
         files = {str(path): path for path in files}  # make a dictionary of paths
@@ -78,15 +78,12 @@ def summarize(files, func, **kwargs):
             {**output, "FILE": name}
         )  # add the file name to the output at the end
 
-    unique_keys = (
-        []
-    )  # get all unique keys, there would be missing or extra keys, handle all
-    for key in [key for out in outputs for key in out.keys()]:
-        if key not in unique_keys:
-            unique_keys.append(key)
+    unique_keys = {} # handle missing keys with types
+    for key,value in [item for out in outputs for item in out.items()]:
+        unique_keys[key] = '' if isinstance(value, str) else None
 
     return pd.DataFrame(
-        {ukey: [out.get(ukey, None) for out in outputs] for ukey in unique_keys}
+        {key: [out.get(key, ph) for out in outputs] for key,ph in unique_keys.items()}
     )
 
 
@@ -102,236 +99,171 @@ def fix_signature(cls):
     cls.__signature__ = inspect.signature(cls.__init__)
     return cls
 
-
-@fix_signature
-class FilesWidget(VBox):
-    """A widget for selecting files from a directory and its subdirectories.
+class Files:
+    """Creates a Batch of files in a directory recursively based on glob pattern or given list of files.
+    This is a boilerplate abstraction to do analysis in multiple calculations simultaneously.
 
     Parameters
     ----------
-    path : str, default is '.'. The path to the directory to search.
-    glob : str, default is '*'. The glob pattern to match files against. See https://docs.python.org/3/library/glob.html
-    exclude : str, default is None. A regex pattern to exclude files from the selection.
-    on_file_changed : callable, default is None.
-        A function that takes path as an argument and is called when the selected file changes. Output is displayed below the widget.
-        To add extra controls and widgets, use `.interactive`/`.interact` methods instead.
-
-    Returns
-    -------
-    A FilesWidget object where you can filter files by typing in the text box, and select files from the dropdown.
-    """
-
-    def __init__(
-        self,
-        path: str = ".",
-        glob: str = "*",
-        exclude: str = None,
-        on_file_changed=None,
-    ) -> None:
-        for prop in (path, glob, exclude):
-            if prop and not isinstance(prop, str):
-                raise ValueError(f"Expected string, got {type(prop)}")
-
-        super().__init__(_dom_classes=["FilesWidget"])  # This makes it truely a widget
-        self._files = []  # Selections stored as Path objects
-        self._widgets = {
-            "input": Text(
-                value=path,
-                description="Path:",
-                tooltip="The path to the directory to search.",
-            ),
-            "glob": Text(
-                value=glob,
-                description="Glob:",
-                tooltip="The glob pattern to match files against. See https://docs.python.org/3/library/glob.html",
-            ),
-            "exclude": Text(
-                value=exclude or "",
-                description="Exclude:",
-                tooltip="A regex pattern to exclude files from the selection.",
-            ),
-            "lock": Checkbox(
-                value=False,
-                description="Lock selection",
-                tooltip="Lock the current selection and prevent changes.",
-            ),
-            "files": Dropdown(
-                options=[], description="File:", tooltip="Select a file from the list."
-            ),
-        }
-        self.children = [
-            self._widgets["input"],
-            self._widgets["glob"],
-            self._widgets["exclude"],
-        ]
-        self._widgets["lock"].observe(self._lock_selection, names=["value"])
-
-        for key, value in self._widgets.items():
-            if key not in ["files", "lock"]:
-                value.on_submit(self._process)
-
-        if on_file_changed:
-            if not callable(on_file_changed):
-                raise TypeError(
-                    "Argument `on_file_changed` must be a function that takes path as an argument."
-                )
-
-            out = ipw.Output()
-            self.layout.max_height = "90vh"  # Only if output is present
-            self._widgets["output"] = out
+    path_or_files : str, current directory by default or list of files or an instance of Files.
+    glob : str, glob pattern, '*' by default. Not used if files supplied above.
+    exclude : str, regular expression pattern to exclude files.
+    files_only : bool, if True, returns only files.
+    dirs_only : bool, if True, returns only directories.
 
-            @out.capture(clear_output=True, wait=True)
-            def on_change(change):
-                on_file_changed(self.selected)
-
-            self._widgets["files"].observe(on_change, names=["value"])
-
-        self._process(None)  # Initial processing based on given values
-
-    def _lock_selection(self, change):
-        for key, value in self._widgets.items():
-            if key not in ["files", "lock"]:
-                value.disabled = self._widgets[
-                    "lock"
-                ].value  # Don't allow changes even programatically
-
-        if self._widgets["lock"].value:
-            self._widgets["lock"].description = f"{len(self._files)} files selected"
-            self.children = [self._widgets["lock"], self._widgets["files"]]
+    Use methods on return such as `summarize`, `with_name`, `filtered`, `interact` and others.
+    """
+    def __init__(self, path_or_files = '.', glob = '*', exclude = None,files_only = False, dirs_only=False):
+        if isinstance(path_or_files, Files):
+            self._files = path_or_files._files
+            return # Do nothing
+        
+        if files_only and dirs_only:
+            raise ValueError("files_only and dirs_only cannot be both True")
+
+        files = []
+        if isinstance(path_or_files,(str, Path)):
+            path = Path(path_or_files)
+            files = [p for p in path.glob(glob)]
         else:
-            self.children = [
-                self._widgets["input"],
-                self._widgets["glob"],
-                self._widgets["exclude"],
-            ]
-
-        if self._widgets.get("output"):
-            self.children = [*self.children, self._widgets["output"]]
-
-    def _process(self, change):
-        self._widgets["lock"].description = "Processing..."
-        files = gu.list_files(
-            self._widgets["input"].value,
-            glob=self._widgets["glob"].value,
-            exclude=self._widgets["exclude"].value,
-        )
-
-        self._widgets["files"].options = [
-            str(p) for p in files
-        ]  # shows only relative path
-        self._files = [path.absolute() for path in files]  # Store as full path
-        self.children = list(self._widgets.values())  #  show all widgets
-        self._widgets[
-            "lock"
-        ].description = f"{len(self._files)} files found. Lock selection?"
-
-    @property
-    def paths(self):
-        "Returns all availble paths."
-        return tuple(self._files)
-
-    @property
-    def dropdown(self):
-        "Returns the dropdown widget to select files."
-        return self._widgets["files"]
-
-    @property
-    def selected(self) -> Path:
-        "Returns selected item in the dropdown as Path object."
-        if self._widgets["files"].value:  # if not empty, otherwise it throws error
-            return Path(self._widgets["files"].value).absolute()  # return full path
-
-    @property
-    def path(self):  # This is in consistent with other widgets too
-        "Return currently selected path."
-        return self.selected
+            others = []
+            for item in path_or_files:
+                if isinstance(item, str):
+                    item = Path(item)
+                elif not isinstance(item, Path):
+                    raise TypeError(f"Expected str or Path in sequence, got {type(item)}")
+                
+                if item.exists():
+                    files.append(item)
+                else:
+                    others.append(str(item))
+                    
+            if others:
+                print(f"Skipping paths that do not exist: {list(set(others))}")
+                
+        if exclude:
+            files = [p for p in files if not re.search(exclude, str(p))]
+        if files_only:
+            files = [p for p in files if p.is_file()]
+        if dirs_only:
+            files = [p for p in files if p.is_dir()]
+            
+        self._files =  tuple(sorted(files))
+
+    def __repr__(self):
+        if not self: return "Files()"
+        return "Files(\n" + ',\n'.join(f'  {f!r}' for f in self._files) + "\n)"
+
+    def __getitem__(self, index): return self._files[index]
+    def __iter__(self): return self._files.__iter__()
+    def __len__(self): return len(self._files)
+    def __bool__(self): return bool(self._files)
+
+    def with_name(self, name):
+        "Change name of all files. Only keeps existing files."
+        return self.__class__([f.with_name(name) for f in self._files])
+
+    def filtered(self, include=None, exclude=None, files_only = False, dirs_only=False):
+        "Filter all files. Only keeps existing file."
+        files = [p for p in self._files if re.search(include, str(p))] if include else self._files
+        return self.__class__(files, exclude=exclude,dirs_only=dirs_only,files_only=files_only)
 
-    def interactive(
-        self,
-        func,
+    def summarize(self, func, **kwargs):
+        "Apply a func(apth) -> dict and create a dataframe."
+        return summarize(self._files,func, **kwargs)
+    
+    def load_results(self):
+        "Load result.json files from these paths into a dataframe."
+        return load_results(self._files)
+    
+    def input_info(self, *tags):
+        "Grab input information into a dataframe from POSCAR and INCAR. Provide INCAR tags (case-insinsitive) to select only few of them."
+        from .lattice import POSCAR
+
+        def info(path, tags):
+            p = POSCAR(path).data 
+            lines = [[v.strip() for v in line.split('=')] 
+                     for line in path.with_name('INCAR').read_text().splitlines() 
+                     if '=' in line]
+            if tags:
+                tags = [t.upper() for t in tags] # can send lowercase tag
+                lines = [(k,v) for k,v in lines if k in tags]
+            d = {k:v for k,v in lines if not k.startswith('#')}
+            d.update({k:len(v) for k,v in p.types.items()})
+            d.update(zip('abcvαβγ', [*p.norms,p.volume,*p.angles]))
+            return d
+        
+        return self.with_name('POSCAR').summarize(info, tags=tags)
+
+    def update(self, path_or_files, glob = '*',**kwargs):
+        "Update files inplace with similar parameters as initialization. Useful for widgets such as BandsWidget to preserve their state while files swapping."
+        self._files = self.__class__(path_or_files, glob = glob, **kwargs)
+        if (dd := getattr(self, '_dd', None)): # update dropdown
+            old = dd.value
+            dd.options = self._files
+            if old in dd.options:
+                dd.value = old
+    
+    def interactive(self, func,
         other_widgets=None,
         other_controls=None,
         options={"manual": False},
         height="400px",
-        **kwargs,
-    ):
+        **kwargs):
         """
         Interact with a function that takes selected Path as first argument. Returns a widget that saves attributes of the function call such as .f, .args, .kwargs.
         See docs of self.interact for more details on the parameters. kwargs are passed to ipywidgets.interactive to create controls.
 
 
-        >>> fw = FilesWidget()
-        >>> out = fw.interactive(lambda path: print(path.read_text())) # prints contents of selected file on output widget
+        >>> fls = Files()
+        >>> out = fls.interactive(lambda path: print(path.read_text())) # prints contents of selected file on output widget
         >>> out.f # function
         >>> out.args # arguments
         >>> out.kwargs # keyword arguments
         >>> out.result # result of function call which is same as out.f(*out.args, **out.kwargs)
-        >>> out.files_widget # reference to FilesWidget created, not the same as fw because it is a new instance
-
 
         .. note::
             If you don't need to interpret the result of the function call, you can use the @self.interact decorator instead.
-
-        .. note::
-            Each time an underlying new FilesWidget instance is created which picks input from previous one but stays separate. You can access it with `.files_widget` attribute of interactive.
         """
-        # Make new FilesWidget with same parameters, to allow multiple interact calls
-        new_fw = self.__class__(
-            path=self._widgets["input"].value,
-            glob=self._widgets["glob"].value,
-            exclude=self._widgets["exclude"].value,
-        )
-        info = ipw.HTML().add_class("FW-Progess")
+        info = ipw.HTML().add_class("fprogess")
+        dd = Dropdown(description='File', options=self._files)
 
         def interact_func(fname, **kwargs):
             if fname:  # This would be None if no file is selected
                 info.value = _progress_svg
                 try:
                     start = time()
-                    print(
-                        f"Running {func.__name__}({fname!r}, {kwargs})"
-                    )  # it also serves as removing the output errors
-                    func(
-                        Path(fname).absolute(), **kwargs
-                    )  # Have Path object absolue if user changes directory
+                    print(f"Running {func.__name__}({fname!r}, {kwargs})")  
+                    func(Path(fname).absolute(), **kwargs)  # Have Path object absolue if user changes directory
                     print(f"Finished in {time() - start:.3f} seconds.")
                 finally:
                     info.value = ""
 
-        out = ipw.interactive(
-            interact_func, options, fname=new_fw._widgets["files"], **kwargs
-        )
-
-        out.files_widget = new_fw  # save reference to FilesWidget
-        out.output_widget = out.children[
-            -1
-        ]  # save reference to output widget for other widgets to use
+        out = ipw.interactive(interact_func, options, fname=dd, **kwargs)
+        out._dd = dd  # save reference to dropdown
+        out.output_widget = out.children[-1]  # save reference to output widget for other widgets to use
 
         if options.get("manual", False):
-            out.interact_button = out.children[
-                -2
-            ]  # save reference to interact button for other widgets to use
+            out.interact_button = out.children[-2]  # save reference to interact button for other widgets to use
 
         output = out.children[-1]  # get output widget
-        output.clear_output(
-            wait=True
-        )  # clear output by waiting to avoid flickering, this is important
+        output.clear_output(wait=True)  # clear output by waiting to avoid flickering, this is important
         output.layout = Layout(
             overflow="auto", max_height="100%", width="100%"
         )  # make output scrollable and avoid overflow
 
         others = out.children[1:-1]  # exclude files_dd and Output widget
         _style = """<style>
-        .FW-Interact {
+        .files-interact {
             --jp-widgets-inline-label-width: 4em;
             --jp-widgets-inline-width: 18em;
             --jp-widgets-inline-width-short: 9em;
         }
-        .FW-Interact {max-height:90vh;width:100%;}
-        .FW-Interact > div {overflow:auto;max-height:100%;padding:8px;}
-        .FW-Interact > div:first-child {width:20em}
-        .FW-Interact > div:last-child {width:calc(100% - 20em)}
-        .FW-Interact .FW-Progess {position:absolute !important; left:50%; top:50%; transform:translate(-50%,-50%); z-index:1}
+        .files-interact {max-height:90vh;width:100%;}
+        .files-interact > div {overflow:auto;max-height:100%;padding:8px;}
+        .files-interact > div:first-child {width:20em}
+        .files-interact > div:last-child {width:calc(100% - 20em)}
+        .files-interact .fprogess {position:absolute !important; left:50%; top:50%; transform:translate(-50%,-50%); z-index:1}
         </style>"""
         if others:
             others = [ipw.HTML(f"<hr/>{_style}"), *others]
@@ -368,19 +300,24 @@ class FilesWidget(VBox):
             HBox(
                 [  # reset children to include new widgets
                     VBox(
-                        children=[new_fw, VBox(others)]
+                        children=[dd, VBox(others)]
                     ),  # other widgets in box to make scrollable independent file selection
                     VBox(
                         children=[Box([output]), *(other_widgets or []), info]
                     ),  # output in box to make scrollable,
                 ],
                 layout=Layout(height=height, max_height=height),
-            ).add_class("FW-Interact")
+            ).add_class("files-interact")
         ]  # important for every widget separately
         return out
-
-    def interact(
-        self,
+    
+    def _attributed_interactive(self, box, func, *args, **kwargs):
+        box._files = self
+        box._interact = self.interactive(func, *args, **kwargs)
+        box.children = box._interact.children
+        box._files._dd = box._interact._dd
+    
+    def interact(self,
         other_widgets=None,
         other_controls=None,
         options={"manual": False},
@@ -388,7 +325,7 @@ class FilesWidget(VBox):
         **kwargs,
     ):
         """Interact with a function that takes a selected Path as first argument.
-        A CSS class 'FW-Interact' is added to the final widget to let you style it.
+        A CSS class 'files-interact' is added to the final widget to let you style it.
 
         Parameters
         ----------
@@ -402,53 +339,43 @@ class FilesWidget(VBox):
         height : str
             Default is '90vh'. height of the final widget. This is important to avoid very long widgets.
 
-
         kwargs are passed to ipywidgets.interactive and decorated function. Resulting widgets are placed below the file selection widget.
-
         `other_widgets` can be controlled by `other_controls` externally. For example, you can add a button to update a plotly's FigureWidget.
 
         The decorated function can be called later separately as well, and has .args and .kwargs attributes to access the latest arguments
         and .result method to access latest. For a function `f`, `f.result` is same as `f(*f.args, **f.kwargs)`.
 
 
-        >>> fw = FilesWidget()
-        >>> @fw.interact(x = False)
+        >>> fls = Files()
+        >>> @fls.interact(x = False)
         >>> def f(path,x):
         >>>     print('path:',path)
         >>>     print('Path Type: ', type(path))
         >>>     print('x: ',x)
 
-
         .. note::
             Use self.interactive to get a widget that stores the argements and can be called later in a notebook cell.
         """
 
         def inner(func):
-            display(
-                self.interactive(
-                    func,
-                    other_widgets=other_widgets,
-                    other_controls=other_controls,
-                    options=options,
-                    height=height,
-                    **kwargs,
-                )
+            display(self.interactive(func,
+                other_widgets=other_widgets,
+                other_controls=other_controls,
+                options=options,
+                height=height,
+                **kwargs)
             )
             return func
-
         return inner
+    
 
-    def summarize(self, func, **kwargs):
-        """Summarize the results from all selected files using a function that takes a Path object as first arguement.
-        kwargs are passed to function. Returns a dataframe."""
-        return summarize(
-            {
-                key: value
-                for key, value in zip(self._widgets["files"].options, self._files)
-            },
-            func,
-            **kwargs,
-        )
+    def kpath_widget(self, height='400px'):
+        "Get KpathWidget instance with these files."
+        return KpathWidget(files = self._files, height = height)
+
+    def bands_widget(self, height='450px'):
+        "Get BandsWidget instance with these files."
+        return BandsWidget(files=self._files, height=height)
 
 
 @fix_signature
@@ -647,12 +574,12 @@ class BandsWidget(VBox):
     Two attributes are important:
     self.clicked_data returns the last clicked point, that can also be stored as VBM, CBM etc, using Click dropdown.
     self.selected_data returns the last selection of points within a box or lasso. You can plot that output separately as plt.plot(data.xs, data.ys) after a selection.
+    You can use `self.files.update` method to change source files without effecting state of widget.
     """
 
-    def __init__(self, use_vaspout=False, height="450px", **file_widget_kwargs):
+    def __init__(self, files, height="450px"):
         super().__init__(_dom_classes=["BandsWidget"])
         self._bands = None
-        self._use_vaspout = use_vaspout
         self._fig = go.FigureWidget()
         self._tsd = Dropdown(
             description="Style", options=["plotly_white", "plotly_dark"]
@@ -668,11 +595,8 @@ class BandsWidget(VBox):
         self._click_dict = {}  # store clicked data
         self._select_dict = {}  # store selection data
         self._kwargs = {}
-        file_widget_kwargs = {
-            "glob": "vapout.h5" if use_vaspout else "vasprun.xml",
-            **file_widget_kwargs,
-        }
-        self._interact = FilesWidget(**file_widget_kwargs).interactive(
+        
+        Files(files)._attributed_interactive(self,
             self._load_data,
             other_widgets=[self._fig],
             other_controls=[
@@ -686,8 +610,7 @@ class BandsWidget(VBox):
             ],
             height=height,
         )
-        self.files_widget = self._interact.files_widget
-        self.children = self._interact.children
+       
         self._tsd.observe(self._change_theme, "value")
         self._click.observe(self._click_save_data, "value")
         self._ktcicks.observe(self._warn_update, "value")
@@ -696,13 +619,18 @@ class BandsWidget(VBox):
     @property
     def path(self):
         "Returns currently selected path."
-        return self.files_widget.path
+        return self._interact._dd.value
+    
+    @property
+    def files(self):
+        "Use slef.files.update(...) to keep state of widget preserved."
+        return self._files
 
     def _load_data(self, path):  # Automatically redirectes to output widget
         self._interact.output_widget.clear_output(wait=True)  # Why need again?
         with self._interact.output_widget:
             self._bands = (
-                vp.Vaspout(path) if self._use_vaspout else vp.Vasprun(path)
+                vp.Vasprun(path) if path.parts[-1].endswith('xml') else vp.Vaspout(path)
             ).bands
             self._ppicks.update(self.bands.source.summary)
             self._ktcicks.value = ", ".join(
@@ -714,7 +642,7 @@ class BandsWidget(VBox):
             else:
                 self._click.options = ["None", "VBM", "CBM"]
 
-            if (file := self.files_widget.selected.parent / "result.json").is_file():
+            if (file := path.parent / "result.json").is_file():
                 self._result = serializer.load(str(file.absolute()))  # Old data loaded
 
             pdata = self.bands.source.poscar.data
@@ -811,7 +739,7 @@ class BandsWidget(VBox):
             serializer.dump(
                 data_dict,
                 format="json",
-                outfile=self.files_widget.selected.parent / "result.json",
+                outfile=self.path.parent / "result.json",
             )
 
         if (
@@ -854,8 +782,8 @@ class BandsWidget(VBox):
 
     @property
     def results(self):
-        "Generate a data frame form result.json file in each folder."
-        return load_results(self.files_widget.paths)
+        "Generate a dataframe form result.json file in each folder."
+        return load_results(self._interact._dd.options)
 
 
 @fix_signature
@@ -870,9 +798,11 @@ class KpathWidget(VBox):
     - To update point(s), select point(s) from the select box and click on a scatter point in figure or use KPOINT input to update it manually, e.g. if a point is not available on plot.
     - Add labels to the points by typing in the "Labels" box such as "Γ,X" or "Γ 5,X" that will add 5 points in interval.
     - To break the path between two points "Γ" and "X" type "Γ 0,X" in the "Labels" box, zero means no points in interval.
+
+    You can use `self.files.update` method to change source files without effecting state of widget.
     """
 
-    def __init__(self, height="400px", **files_widget_kwargs):
+    def __init__(self, files, height="400px"):
         super().__init__(_dom_classes=["KpathWidget"])
         self._fig = go.FigureWidget()
         self._sm = SelectMultiple(options=[], layout=Layout(width="auto"))
@@ -894,13 +824,11 @@ class KpathWidget(VBox):
             self._lab,
             self._kpt,
         ]
-        files_widget_kwargs = {"glob": "POSCAR", **files_widget_kwargs}
-        self._interact = FilesWidget(**files_widget_kwargs).interactive(
+        
+        Files(files)._attributed_interactive(self,
             self._update_fig, [self._fig], other_controls, height=height
         )
-        self.files_widget = self._interact.files_widget  # sometimes useful
-        self.children = self._interact.children
-
+        
         self._tsb.on_click(self._update_theme)
         self._add.on_click(self._toggle_lock)
         self._del.on_click(self._del_point)
@@ -910,7 +838,12 @@ class KpathWidget(VBox):
     @property
     def path(self):
         "Returns currently selected path."
-        return self._interact.files_widget.path
+        return self._interact._dd.value # itself a Path object
+    
+    @property
+    def files(self):
+        "Use slef.files.update(...) to keep state of widget preserved."
+        return self._files
 
     @property
     def poscar(self):

{ipyvasp-0.9.2.dist-info → ipyvasp-0.9.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ipyvasp
-Version: 0.9.2
+Version: 0.9.3
 Summary: A processing tool for VASP DFT input/output processing in Jupyter Notebook.
 Home-page: https://github.com/massgh/ipyvasp
 Author: Abdul Saboor

{ipyvasp-0.9.2.dist-info → ipyvasp-0.9.3.dist-info}/RECORD

@@ -1,25 +1,25 @@
-ipyvasp/__init__.py,sha256=7o41i5eYlNKg1Hsv0DLNFZ81GilxB02IXAJN-QiJQi0,1420
+ipyvasp/__init__.py,sha256=rlorju9arMtHw1QRYPljday-PyZWJdSCxg4lw3g6t0Q,1409
 ipyvasp/__main__.py,sha256=eJV1TZSiT8mC_VqAeksNnBI2I8mKMiPkEIlwikbtOjI,216
 ipyvasp/_enplots.py,sha256=D38paN8zqZgluNAwmCwcocd7-_h_T0HTGolI1eBkDes,37484
-ipyvasp/_lattice.py,sha256=DN3VZVjQ5fbzUrbpft75ieaP5ddyr6mIuZRHOwrFrK8,103052
-ipyvasp/_version.py,sha256=I3ASgj0LYAmGGQhqxkAYEEiiLOpQ1UAZGOd0bJAXSRw,23
-ipyvasp/bsdos.py,sha256=ZtQji-W11UdFFicAoWZjlqVhI5tqYu_jpKyPPWKkeeo,30634
+ipyvasp/_lattice.py,sha256=GxG0C4lwVGvBYIy3jwR1kahWR7L6kJlqjIiQGgESjcM,104135
+ipyvasp/_version.py,sha256=5uBZ3sUaocnyIWuJeW9M94Z77vA1kKmwKxiblrnbKlc,23
+ipyvasp/bsdos.py,sha256=1rG68S-dLEYveIWGK7r8CRa7Qqlqno0l1ncfo2ocihk,30424
 ipyvasp/cli.py,sha256=aWFEVhNmnW8eSOp5uh95JaDwLQ9K9nlCQcbnOSuhWgw,6844
 ipyvasp/evals_dataframe.py,sha256=-sqxK7LPV6sYDO_XXmZ80FznOaXTkVdbqJKKvTUtMak,20637
-ipyvasp/lattice.py,sha256=wz5CKv5YJbELvG2lbrYnXoT7u9R70Jkr_i3olE4Hx4I,30643
+ipyvasp/lattice.py,sha256=t4s1qh6IJsoeXcCa9M9IhjAQp2s78lqiGhOfEkCW19s,30638
 ipyvasp/misc.py,sha256=SZJ_ePUR2-HEKYTEpDHVRVE7zpIQVTCjiuw0BCC9UTU,2349
 ipyvasp/potential.py,sha256=tzA73c5lkp6ahLSJchMrU043-QWaOV0nIOUA7VMmfKQ,11408
 ipyvasp/surface.py,sha256=MjE5oB0wW6Pca_C-xu8rN6OMH7lUEeNPNyM7Kz_Im-8,23766
-ipyvasp/utils.py,sha256=hiAV76jEMuDt1Wp22imrnsSgetjxmUKlskRA7CcK6BU,15261
-ipyvasp/widgets.py,sha256=fZ2b7EYYxuaAVfklnLa0VJ00U9Uyd7SqXrzt0hbLOvI,45400
+ipyvasp/utils.py,sha256=rVyD5SkO_Y7ok5W-fJeQys9X8pLLbDK7VOgbAbcE4WU,14227
+ipyvasp/widgets.py,sha256=mP1tqYO-tPk4Xq_fgkGPGN2AfRf9V-al3Yl7vzKp5lU,43758
 ipyvasp/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ipyvasp/core/parser.py,sha256=C3CaZsJbPME_ttYlYy4DXeOdL7dnkXs-cHRwFZL6bio,38058
 ipyvasp/core/plot_toolkit.py,sha256=8t5svyWbOm-PS7ZvIptnK6F46kp6uwoGNdohPv5dQKA,35962
 ipyvasp/core/serializer.py,sha256=XpqnfVGsUXiN2CuVRPyqsSVouxRBO-UH6AnsHnPYvZY,36729
 ipyvasp/core/spatial_toolkit.py,sha256=8DBYTiBFWJ7OBKuvOPw7UoEVCyNjJhSW0OcudjYZvAw,14748
-ipyvasp-0.9.2.dist-info/LICENSE,sha256=F3SO5RiAZOMfmMGf1KOuk2g_c4ObvuBJhd9iBLDgXoQ,1263
-ipyvasp-0.9.2.dist-info/METADATA,sha256=rbDpOJNtuinZ9AJi0pBcBTAYHLuoC_IbBvQagjXSHG4,2420
-ipyvasp-0.9.2.dist-info/WHEEL,sha256=iYlv5fX357PQyRT2o6tw1bN-YcKFFHKqB_LwHO5wP-g,110
-ipyvasp-0.9.2.dist-info/entry_points.txt,sha256=C7m0Sjmr14wFjflCkWXLzr5N6-cQj8uJC9n82mUtzt8,44
-ipyvasp-0.9.2.dist-info/top_level.txt,sha256=ftziWlMWu_1VpDP1sRTFrkfBnWxAi393HYDVu4wRhUk,8
-ipyvasp-0.9.2.dist-info/RECORD,,
+ipyvasp-0.9.3.dist-info/LICENSE,sha256=F3SO5RiAZOMfmMGf1KOuk2g_c4ObvuBJhd9iBLDgXoQ,1263
+ipyvasp-0.9.3.dist-info/METADATA,sha256=v2jvMQ--zKh-b0GAF5XywZDMKJi8x3hUAMMvKGdfiD0,2420
+ipyvasp-0.9.3.dist-info/WHEEL,sha256=iYlv5fX357PQyRT2o6tw1bN-YcKFFHKqB_LwHO5wP-g,110
+ipyvasp-0.9.3.dist-info/entry_points.txt,sha256=C7m0Sjmr14wFjflCkWXLzr5N6-cQj8uJC9n82mUtzt8,44
+ipyvasp-0.9.3.dist-info/top_level.txt,sha256=ftziWlMWu_1VpDP1sRTFrkfBnWxAi393HYDVu4wRhUk,8
+ipyvasp-0.9.3.dist-info/RECORD,,