xarpes 0.6.3__py3-none-any.whl → 0.6.5__py3-none-any.whl

xarpes/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.3"
+__version__ = "0.6.5"
 
 from importlib import import_module
 

xarpes/functions.py

@@ -236,7 +236,6 @@ def fit_least_squares(p0, xdata, ydata, function, resolution=None, yerr=None,
     return pfit, pcov, success
 
 
-
 def download_examples():
     """Downloads the examples folder from the main xARPES repository only if it
     does not already exist in the current directory. Prints executed steps and a
@@ -625,4 +624,168 @@ def chi2kink_logistic(x, a, b, c, d):
         expz = np.exp(z[mneg])
         phi[mneg] = a + b * expz / (1.0 + expz)
 
-    return phi
+    return phi
+
+def _in_ipython():
+    try:
+        from IPython import get_ipython
+    except Exception:
+        return False
+    return get_ipython() is not None
+
+
+class _LineBuffer:
+    """Capture text as lines, keeping only head + tail and total count."""
+    def __init__(self, head=10, tail=10):
+        from collections import deque
+        self.head = int(head)
+        self.tail = int(tail)
+        self._head_lines = []
+        self._tail_lines = deque(maxlen=self.tail)
+        self._partial = ""
+        self._n_lines = 0
+
+    def feed(self, text):
+        if not text:
+            return
+
+        # Normalize carriage returns (progress bars etc.)
+        text = str(text).replace("\r", "\n")
+
+        # Prepend any partial line from previous write.
+        text = self._partial + text
+        parts = text.split("\n")
+
+        # If text does not end with '\n', last part is partial.
+        self._partial = parts.pop()  # may be "" if ended with newline
+
+        for line in parts:
+            # Record completed line
+            self._n_lines += 1
+            if len(self._head_lines) < self.head:
+                self._head_lines.append(line)
+            else:
+                if self.tail > 0:
+                    self._tail_lines.append(line)
+
+    def finalize(self):
+        # If there is an unfinished line, treat it as a line.
+        if self._partial.strip() != "":
+            self.feed("\n")  # forces it into completed lines
+        self._partial = ""
+
+    def summary(self):
+        self.finalize()
+
+        n = self._n_lines
+        if n == 0:
+            return ""
+
+        # If total small, reconstruct from head + tail if possible
+        if n <= self.head + self.tail:
+            # We didn't keep all middle lines, but if n <= head+tail we kept all.
+            # For n <= head, tail may be empty; for n > head, tail contains rest.
+            out = list(self._head_lines)
+            if n > len(self._head_lines):
+                out.extend(list(self._tail_lines))
+            return "\n".join(out)
+
+        omitted = n - self.head - self.tail
+        head_txt = "\n".join(self._head_lines)
+        tail_txt = "\n".join(list(self._tail_lines))
+        return (
+            f"{head_txt}\n"
+            f"... ({omitted} lines omitted) ...\n"
+            f"{tail_txt}"
+        )
+
+
+def trim_notebook_output(print_lines=10, *, enabled=True, clear=True,
+                         capture_stderr=True, sleep_s=0.05):
+    """Context manager: show live prints, then keep only head/tail in notebooks.
+
+    In plain scripts (no IPython), this is a no-op.
+    """
+    from contextlib import contextmanager
+
+    @contextmanager
+    def _ctx():
+        if (not enabled) or (print_lines is None):
+            yield
+            return
+
+        n = int(print_lines)
+        if n <= 0:
+            yield
+            return
+
+        # Only do this in IPython environments; scripts should print normally.
+        if not _in_ipython():
+            yield
+            return
+
+        import sys
+        import time
+
+        buf = _LineBuffer(head=n, tail=n)
+
+        stdout_orig = sys.stdout
+        stderr_orig = sys.stderr
+
+        class _TeeStream:
+            def __init__(self, real_stream, buffer):
+                self._real = real_stream
+                self._buf = buffer
+
+            def write(self, text):
+                # Live output
+                try:
+                    self._real.write(text)
+                    self._real.flush()
+                except Exception:
+                    pass
+                # Capture
+                self._buf.feed(text)
+
+            def flush(self):
+                try:
+                    self._real.flush()
+                except Exception:
+                    pass
+
+            # Some libraries ask for these:
+            def isatty(self):
+                return False
+
+            @property
+            def encoding(self):
+                return getattr(self._real, "encoding", "utf-8")
+
+        sys.stdout = _TeeStream(stdout_orig, buf)
+        if capture_stderr:
+            sys.stderr = _TeeStream(stderr_orig, buf)
+
+        try:
+            yield
+        finally:
+            # Restore streams first.
+            sys.stdout = stdout_orig
+            sys.stderr = stderr_orig
+
+            # Let Jupyter finish rendering any queued output.
+            if sleep_s:
+                time.sleep(float(sleep_s))
+
+            # Clear cell output and print summary.
+            summary = buf.summary()
+            if clear:
+                try:
+                    from IPython.display import clear_output
+                    clear_output(wait=True)
+                except Exception:
+                    pass
+
+            if summary:
+                print(summary)
+
+    return _ctx()

xarpes/selfenergies.py

@@ -1711,6 +1711,7 @@ class SelfEnergy:
 
         return spectrum, model, omega_range, alpha_select, cost, params
 
+
     @staticmethod
     def _merge_defaults(defaults, override_dict=None, override_kwargs=None):
         """Merge defaults with dict + kwargs overrides (kwargs win)."""
@@ -2147,6 +2148,101 @@ class SelfEnergy:
         return spectrum_out, alpha_select, fit_curve, guess_curve, chi2kink_result
 
 
+    @staticmethod
+    def _trimmed_stdout(print_lines):
+        """Optionally tee stdout+stderr and replace final output with head/tail."""
+        from contextlib import contextmanager
+
+        @contextmanager
+        def _ctx():
+            if print_lines is None:
+                yield
+                return
+
+            n = int(print_lines)
+            import sys
+            import io
+
+            class _Tee:
+                def __init__(self, out_stream, err_stream, nlines):
+                    self.out_stream = out_stream
+                    self.err_stream = err_stream
+                    self.nlines = int(nlines)
+                    self.buf = io.StringIO()
+
+                def write(self, text):
+                    # Jupyter sometimes calls write with empty strings
+                    if text is None:
+                        return
+                    if self.nlines > 0:
+                        self.out_stream.write(text)
+                        self.out_stream.flush()
+                    self.buf.write(text)
+
+                def flush(self):
+                    self.out_stream.flush()
+
+                def err_write(self, text):
+                    if text is None:
+                        return
+                    if self.nlines > 0:
+                        self.err_stream.write(text)
+                        self.err_stream.flush()
+                    self.buf.write(text)
+
+                def err_flush(self):
+                    self.err_stream.flush()
+
+                def cleaned(self):
+                    lines = self.buf.getvalue().splitlines()
+                    if self.nlines <= 0:
+                        return ""
+
+                    if len(lines) <= 2 * self.nlines:
+                        return "\n".join(lines)
+
+                    head = lines[:self.nlines]
+                    tail = lines[-self.nlines:]
+                    omitted = len(lines) - 2 * self.nlines
+                    mid = f"... ({omitted} lines omitted) ..."
+                    return "\n".join(head + [mid] + tail)
+
+            stdout_orig = sys.stdout
+            stderr_orig = sys.stderr
+
+            tee = _Tee(stdout_orig, stderr_orig, n)
+
+            class _ErrProxy:
+                def write(self, text):
+                    tee.err_write(text)
+
+                def flush(self):
+                    tee.err_flush()
+
+            try:
+                sys.stdout = tee
+                sys.stderr = _ErrProxy()
+                yield
+            finally:
+                sys.stdout = stdout_orig
+                sys.stderr = stderr_orig
+
+                try:
+                    from IPython.display import clear_output
+                    clear_output(wait=True)
+                except Exception:
+                    pass
+
+                cleaned = tee.cleaned()
+                if cleaned:
+                    print(cleaned)
+                else:
+                    # Avoid a "blank cell" surprise.
+                    print("(output trimmed; nothing captured from stdout/stderr)")
+
+        return _ctx()
+
+
     @staticmethod
     def _el_el_self_energy(enel_range, k_BT, lambda_el, W, power):
         """Electron–electron contribution to the self-energy."""

{xarpes-0.6.3.dist-info → xarpes-0.6.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xarpes
-Version: 0.6.3
+Version: 0.6.5
 Summary: Extraction from angle resolved photoemission spectra
 Author: xARPES Developers
 Requires-Python: >=3.7.0

{xarpes-0.6.3.dist-info → xarpes-0.6.5.dist-info}/RECORD

@@ -1,15 +1,15 @@
-xarpes/__init__.py,sha256=I3xq0d87dR2rGdO7N2rhLAcg1S_DDrPpArMy3AUTg70,756
+xarpes/__init__.py,sha256=DFt2W5mUNCCXIJt4Q_h3xsCQn0U9nqO_3C1bEguzLnw,756
 xarpes/bandmap.py,sha256=1B5GbRXFdBPqnmeKPJW0mzlz-IUoLD-28rxrThpp4co,34664
 xarpes/constants.py,sha256=XOdgSzyrmHr5xocHZfmcFHHoVAa1G05a305hm3XOTtY,504
 xarpes/distributions.py,sha256=pC8V5MlZDNFdooMonFREEASiN5QodHiyKc2ehnxMKvQ,23498
-xarpes/functions.py,sha256=ibWoSa7_yXD9XsIEif0kbbbHidIozBivvaAEui9f64A,20675
+xarpes/functions.py,sha256=oVAdNY0g44h7h6bXI8IYCiNbXfrLvBk7xD79ZQnbhno,25404
 xarpes/mdcs.py,sha256=WRKSfGlRVKBssJp9FIHcAFsINVunPkmW9fBnFjqBHYI,42844
 xarpes/plotting.py,sha256=lGCReHcXhYLQXR5ns3EHFjCQjJ9Sc-HifV7n4BnWby4,5189
-xarpes/selfenergies.py,sha256=iP4WDPpcS5-3lyoREC0YaJZm3QXFdukvMD1_oH3I6mc,81141
+xarpes/selfenergies.py,sha256=stbKhpDt49F8QTancIpOhgpTrdRvTvCBhvH770p0y-U,84176
 xarpes/settings_parameters.py,sha256=yOYvgEiDeDiLzzLkvysCTiVwqg6fKIkN48B-WSad728,1912
 xarpes/settings_plots.py,sha256=X-qteB2fIbBKOAcLMvMYDfQ8QdlUeA5xYQqF_Nyb4uA,1562
-xarpes-0.6.3.dist-info/entry_points.txt,sha256=917UR-cqFTMMI_vMqIbk7boYSuFX_zHwQlXKcj9vlCE,79
-xarpes-0.6.3.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-xarpes-0.6.3.dist-info/WHEEL,sha256=jPMR_Dzkc4X4icQtmz81lnNY_kAsfog7ry7qoRvYLXw,81
-xarpes-0.6.3.dist-info/METADATA,sha256=zNYkNUXTutskjLjtaeM8BaXh7WcHc6jGE57UBEMhp1A,7154
-xarpes-0.6.3.dist-info/RECORD,,
+xarpes-0.6.5.dist-info/entry_points.txt,sha256=917UR-cqFTMMI_vMqIbk7boYSuFX_zHwQlXKcj9vlCE,79
+xarpes-0.6.5.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+xarpes-0.6.5.dist-info/WHEEL,sha256=jPMR_Dzkc4X4icQtmz81lnNY_kAsfog7ry7qoRvYLXw,81
+xarpes-0.6.5.dist-info/METADATA,sha256=sgr0wwth6Z-sAC4JaIlDXV_PCg9jFX8_F6ZracOhZO4,7154
+xarpes-0.6.5.dist-info/RECORD,,