ipyvasp 0.9.2__py2.py3-none-any.whl → 0.9.4__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.4"

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/core/plot_toolkit.py

@@ -1019,7 +1019,7 @@ def iplot2widget(fig, fig_widget=None, template=None):
     elif not isinstance(fig_widget, go.FigureWidget):
         raise ValueError("fig_widget must be FigureWidget")
     else:
-        scene = fig_widget.layout.scene # keep scene from widget
+        scene = fig_widget.layout.scene if fig_widget.data else fig.layout.scene# keep scene from widget, but if looks a new fig, keep from previous
 
     fig_widget.data = []  # Clear previous data
     if template is not None:

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,257 +99,215 @@ 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
-
-            @out.capture(clear_output=True, wait=True)
-            def on_change(change):
-                on_file_changed(self.selected)
+    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.
 
-            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
+            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 map(self,func):
+        "Map files to a function!"
+        return map(func, 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)
 
-    @property
-    def path(self):  # This is in consistent with other widgets too
-        "Return currently selected path."
-        return self.selected
-
-    def interactive(
-        self,
-        func,
-        other_widgets=None,
-        other_controls=None,
+    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, *args,
+        free_widgets=None,
         options={"manual": False},
         height="400px",
-        **kwargs,
-    ):
+        panel_size = 25,
+        **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.
+        Interact with `func(path, *args, <free_widgets,optional>, **kwargs)` that takes selected Path as first argument. Returns a widget that saves attributes of the function call such as .f, .args, .kwargs.
+        `args` are widgets to be modified by func, such as plotly's FigureWidget.
+        Note that `free_widgets` can also be passed to function but does not run function when changed.
+
         See docs of self.interact for more details on the parameters. kwargs are passed to ipywidgets.interactive to create controls.
 
+        >>> import plotly.graph_objects as go
+        >>> import ipyvasp as ipv
+        >>> fs = ipv.Files('.','**/POSCAR')
+        >>> def plot(path, fig, bl,plot_cell,eqv_sites):
+        >>>     ipv.iplot2widget(ipv.POSCAR(path).iplot_lattice(
+        >>>         bond_length=bl,plot_cell=plot_cell,eqv_sites=eqv_sites
+        >>>      ),fig_widget=fig) # it keeps updating same view
+        >>> out = fs.interactive(plot, go.FigureWidget(),bl=(0,6,2),plot_cell=True, eqv_sites=True)
 
-        >>> fw = FilesWidget()
-        >>> out = fw.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):
+        def interact_func(fname, **kws):
             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
+                    if 'free_widgets' in func.__code__.co_varnames:
+                        kws['free_widgets'] = free_widgets # user allowed to pass this
+                    names = ', '.join(func.__code__.co_varnames)
+                    print(f"Running {func.__name__}({names})")  
+                    func(Path(fname).absolute(), *args, **kws)  # 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 {
+        if not isinstance(panel_size,int):
+            raise TypeError('panel_size should be integer in units of em')
+        
+        _style = f"""<style>
+        .files-interact {{
             --jp-widgets-inline-label-width: 4em;
-            --jp-widgets-inline-width: 18em;
+            --jp-widgets-inline-width: {panel_size-2}em;
             --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:{height};width:100%;}}
+        .files-interact > div {{overflow:auto;max-height:100%;padding:8px;}}
+        .files-interact > div:first-child {{width:{panel_size}em}}
+        .files-interact > div:last-child {{width:calc(100% - {panel_size}em)}}
+        .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]
         else:
             others = [ipw.HTML(_style)]
 
-        if other_controls and not isinstance(other_controls, (list, tuple)):
-            raise TypeError("other_controls must be a list or tuple of widgets.")
-
-        if other_widgets and not isinstance(other_widgets, (list, tuple)):
-            raise TypeError("other_widgets must be a list or tuple of widgets.")
-
-        if other_widgets:
+        if free_widgets and not isinstance(free_widgets, (list, tuple)):
+            raise TypeError("free_widgets must be a list or tuple of widgets.")
+        
+        for w in args:
+            if not isinstance(w,ipw.DOMWidget):
+                raise TypeError(f'args can only contain a DOMWidget instance, got {type(w)}')
+        
+        if args:
             output.layout.max_height = "200px"
+            output.layout.min_height = "8em" # fisrt fix
             out_collapser = Checkbox(description="Hide output widget", value=False)
 
             def toggle_output(change):
                 if out_collapser.value:
                     output.layout.height = "0px"  # dont use display = 'none' as it will clear widgets and wont show again
+                    output.layout.min_height = "0px"
                 else:
                     output.layout.height = "auto"
+                    output.layout.min_height = "8em"
 
             out_collapser.observe(toggle_output, "value")
             others.append(out_collapser)
@@ -361,94 +316,92 @@ class FilesWidget(VBox):
         others = [
             *others,
             ipw.HTML(f"<hr/>"),
-            *(other_controls or []),
+            *(free_widgets or []),
         ]  # add hr to separate other controls
 
         out.children = [
             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]
+                        children=[output, *args, 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,
-        other_widgets=None,
-        other_controls=None,
+    
+    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, *args,
+        free_widgets=None,
         options={"manual": False},
         height="400px",
+        panel_size=25,
         **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.
+        """Interact with a `func(path, *args, <free_widgets,optional>, **kwargs)`. `path` is passed from selected File.
+        A CSS class 'files-interact' is added to the final widget to let you style it.
 
         Parameters
         ----------
-        other_widgets : list/tuple
+        args : 
             Any displayable widget can be passed. These are placed below the output widget of interact.
-            For example you can add plotly's FigureWidget that updates based on the selection, but is not part of the function, so it is displayed only once.
-        other_controls : list/tuple
-            Default is None. If not None, these are assumed to be ipywidgets and are placed below the widgets created by kwargs. These are not passed to the decorated function.
+            For example you can add plotly's FigureWidget that updates based on the selection, these are passed to function after path.
+        free_widgets : list/tuple
+            Default is None. If not None, these are assumed to be ipywidgets and are placed below the widgets created by kwargs. 
+            These can be passed to the decorated function if added as arguemnt there like `func(..., free_widgets)`, but don't trigger execution.
         options : dict
-            Default is {'manua':False}. If True, the decorated function is not called automatically, and you have to call it manually on button press. You can pass button name as 'manual_name' in options.
+            Default is {'manual':False}. If True, the decorated function is not called automatically, and you have to call it manually on button press. You can pass button name as 'manual_name' in options.
         height : str
             Default is '90vh'. height of the final widget. This is important to avoid very long widgets.
-
+        panel_size: int
+            Side panel size in units of em.
 
         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.
+        Widgets in `args` can be controlled by `free_widgets` externally if defined gloablly or inside function if you pass `free_widgets` as argument like `func(..., free_widgets)`.
 
         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)
-        >>> def f(path,x):
-        >>>     print('path:',path)
-        >>>     print('Path Type: ', type(path))
-        >>>     print('x: ',x)
-
+        >>> import plotly.graph_objects as go
+        >>> import ipyvasp as ipv
+        >>> fs = ipv.Files('.','**/POSCAR')
+        >>> @fs.interact(go.FigureWidget(),bl=(0,6,2),plot_cell=True, eqv_sites=True)
+        >>> def plot(path, fig, bl,plot_cell,eqv_sites):
+        >>>     ipv.iplot2widget(ipv.POSCAR(path).iplot_lattice(
+        >>>         bond_length=bl,plot_cell=plot_cell,eqv_sites=eqv_sites
+        >>>      ),fig_widget=fig) # it keeps updating same view
 
         .. 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, *args,
+                free_widgets=free_widgets,
+                options=options,
+                height=height,
+                panel_size=panel_size,
+                **kwargs)
             )
             return func
-
         return inner
+    
+    def kpath_widget(self, height='400px'):
+        "Get KpathWidget instance with these files."
+        return KpathWidget(files = self.with_name('POSCAR'), height = height)
 
-    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 bands_widget(self, height='450px'):
+        "Get BandsWidget instance with these files."
+        return BandsWidget(files=self._files, height=height)
 
 
 @fix_signature
@@ -647,12 +600,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,14 +621,9 @@ 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(
-            self._load_data,
-            other_widgets=[self._fig],
-            other_controls=[
+        
+        Files(files)._attributed_interactive(self, self._load_data, self._fig,
+            free_widgets=[
                 self._tsd,
                 self._brange,
                 self._ktcicks,
@@ -686,8 +634,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 +643,19 @@ 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
+    def _load_data(self, path, fig):  # Automatically redirectes to output widget
+        if not hasattr(self, '_interact'): return  # First time not availablebu 
         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 +667,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
@@ -756,6 +709,7 @@ class BandsWidget(VBox):
         return self._select_dict.get("data", None)
 
     def _update_graph(self, btn):
+        if not hasattr(self, '_interact'): return  # First time not available
         self._interact.output_widget.clear_output(wait=True)  # Why need again?
         with self._interact.output_widget:
             hsk = [
@@ -811,7 +765,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 +808,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 +824,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"))
@@ -885,7 +841,7 @@ class KpathWidget(VBox):
         self._clicktime = None
         self._kpoints = {}
 
-        other_controls = [
+        free_widgets = [
             HBox([self._add, self._del, self._tsb], layout=Layout(min_height="24px")),
             ipw.HTML(
                 "<style>.KpathWidget .widget-select-multiple { min-height: 180px; }\n .widget-select-multiple > select {height: 100%;}</style>"
@@ -894,13 +850,11 @@ class KpathWidget(VBox):
             self._lab,
             self._kpt,
         ]
-        files_widget_kwargs = {"glob": "POSCAR", **files_widget_kwargs}
-        self._interact = FilesWidget(**files_widget_kwargs).interactive(
-            self._update_fig, [self._fig], other_controls, height=height
+        
+        Files(files)._attributed_interactive(self,
+            self._update_fig, self._fig, free_widgets=free_widgets, 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,14 +864,20 @@ 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):
         "POSCAR class associated to current selection."
         return self._poscar
 
-    def _update_fig(self, path):
+    def _update_fig(self, path, fig):
+        if not hasattr(self, '_interact'): return  # First time not available
         from .lattice import POSCAR  # to avoid circular import
 
         with self._interact.output_widget:
@@ -926,10 +886,10 @@ class KpathWidget(VBox):
             )
             self._poscar = POSCAR(path)
             ptk.iplot2widget(
-                self._poscar.iplot_bz(fill=False, color="red"), self._fig, template
+                self._poscar.iplot_bz(fill=False, color="red"), fig, template
             )
-            with self._fig.batch_animate():
-                self._fig.add_trace(
+            with fig.batch_animate():
+                fig.add_trace(
                     go.Scatter3d(
                         x=[],
                         y=[],

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ipyvasp
-Version: 0.9.2
+Version: 0.9.4
 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.4.dist-info/RECORD

@@ -0,0 +1,25 @@
+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=GxG0C4lwVGvBYIy3jwR1kahWR7L6kJlqjIiQGgESjcM,104135
+ipyvasp/_version.py,sha256=iPcoATf7BiWjSu-KocRdM5zFTR4wx4ktCHlGGpvdc1M,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=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=rVyD5SkO_Y7ok5W-fJeQys9X8pLLbDK7VOgbAbcE4WU,14227
+ipyvasp/widgets.py,sha256=iWkH7PbzZFPUZ2LrSRLafTPxXfiRfNFG5Ddaq3Wd_BU,45655
+ipyvasp/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ipyvasp/core/parser.py,sha256=C3CaZsJbPME_ttYlYy4DXeOdL7dnkXs-cHRwFZL6bio,38058
+ipyvasp/core/plot_toolkit.py,sha256=3RoPsND5gPssBSfS5H4TjoZ2Qz7B97vpxeKadc2cRRs,36046
+ipyvasp/core/serializer.py,sha256=XpqnfVGsUXiN2CuVRPyqsSVouxRBO-UH6AnsHnPYvZY,36729
+ipyvasp/core/spatial_toolkit.py,sha256=8DBYTiBFWJ7OBKuvOPw7UoEVCyNjJhSW0OcudjYZvAw,14748
+ipyvasp-0.9.4.dist-info/LICENSE,sha256=F3SO5RiAZOMfmMGf1KOuk2g_c4ObvuBJhd9iBLDgXoQ,1263
+ipyvasp-0.9.4.dist-info/METADATA,sha256=PvaEna3-zdOpEQhg5_iD9ECRt7N4nqI5aPluv6-VJ9M,2420
+ipyvasp-0.9.4.dist-info/WHEEL,sha256=iYlv5fX357PQyRT2o6tw1bN-YcKFFHKqB_LwHO5wP-g,110
+ipyvasp-0.9.4.dist-info/entry_points.txt,sha256=C7m0Sjmr14wFjflCkWXLzr5N6-cQj8uJC9n82mUtzt8,44
+ipyvasp-0.9.4.dist-info/top_level.txt,sha256=ftziWlMWu_1VpDP1sRTFrkfBnWxAi393HYDVu4wRhUk,8
+ipyvasp-0.9.4.dist-info/RECORD,,

ipyvasp-0.9.2.dist-info/RECORD

@@ -1,25 +0,0 @@
-ipyvasp/__init__.py,sha256=7o41i5eYlNKg1Hsv0DLNFZ81GilxB02IXAJN-QiJQi0,1420
-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/cli.py,sha256=aWFEVhNmnW8eSOp5uh95JaDwLQ9K9nlCQcbnOSuhWgw,6844
-ipyvasp/evals_dataframe.py,sha256=-sqxK7LPV6sYDO_XXmZ80FznOaXTkVdbqJKKvTUtMak,20637
-ipyvasp/lattice.py,sha256=wz5CKv5YJbELvG2lbrYnXoT7u9R70Jkr_i3olE4Hx4I,30643
-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/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,,