orto 1.13.1__py3-none-any.whl → 1.14.1__py3-none-any.whl

orto/__version__.py

@@ -1 +1 @@
-__version__ = '1.13.1'
+__version__ = '1.14.1'

orto/cli.py

@@ -1076,123 +1076,290 @@ def gen_job_func(uargs):
     return
 
 
-def plot_xes_func(uargs):
+def plot_xes_func(uargs, save_data_only=False):
     '''
-    Wrapper for CLI plot xes call
+    Wrapper for CLI plot abs call\n\n
+
+    Plots ABSORPTION blocks from orca output\n
+        - UVVIS (TDDFT)\n
+        - XAS (TDDFT)\n\n
 
     Parameters
     ----------
     uargs: argparser object
         User arguments
 
+    save_data_only: bool, default=False
+        If True, saves generated spectrum data to file only.
+
     Returns
     -------
     None
     '''
-    import matplotlib.pyplot as plt
     from . import plotter
     from . import extractor as oe
+    from . import data as d
 
-    # Set user specified font name
-    ut.check_font_envvar()
+    # Process x_shift argument
+    if uargs.x_shift is None:
+        uargs.x_shift = [0.0 for _ in uargs.output_file]
+    elif len(uargs.x_shift) != len(uargs.output_file):
+        ut.red_exit(
+            'Number of x_shift values must match number of output files'
+        )
 
-    # Change matplotlib font size to be larger
-    plt.rcParams['font.size'] = 10
-    plt.rcParams['legend.fontsize'] = 9
+    # Create dictionary to hold absorption data for plotting later
+    spectra_dict = {}
 
-    version = oe.OrcaVersionExtractor.extract(uargs.output_file)
+    # Extract data from each output file
+    for it, output_file in enumerate(uargs.output_file):
 
-    if not len(version):
-        ut.cprint(
-            'Warning: Cannot find version number in Orca output file',
-            'black_yellowbg'
-        )
-        version = [6, 0, 0]
+        version = oe.OrcaVersionExtractor.extract(output_file)
 
-    if version[0] >= 6:
-        if uargs.intensities == 'electric':
-            all_data = oe.XESElectricDipoleExtractor.extract(
-                uargs.output_file
-            )
-        elif uargs.intensities == 'velocity':
-            all_data = oe.XESVelocityDipoleExtractor.extract(
-                uargs.output_file
-            )
-        elif uargs.intensities == 'semi-classical':
-            all_data = oe.XESSemiClassicalDipoleExtractor.extract(
-                uargs.output_file
-            )
-        elif uargs.intensities == 'so_electric':
-            all_data = oe.SOXESElectricDipoleExtractor.extract(
-                uargs.output_file
-            )
-        elif uargs.intensities == 'so_velocity':
-            all_data = oe.SOXESVelocityDipoleExtractor.extract(
-                uargs.output_file
+        if not len(version):
+            ut.cprint(
+                'Warning: Cannot find version number in Orca output file',
+                'black_yellowbg'
             )
-        elif uargs.intensities == 'so_semi-classical':
-            all_data = oe.SOXESSemiClassicalDipoleExtractor.extract(
-                uargs.output_file
+            version = [6, 0, 0]
+
+        # Extract absorption data from file
+        # using appropriate extractor for version
+        # and intensity type
+        if version[0] >= 6:
+            if uargs.intensities == 'electric':
+                all_datasets = oe.XESElectricDipoleExtractor.extract(
+                    output_file
+                )
+            elif uargs.intensities == 'velocity':
+                all_datasets = oe.XESVelocityDipoleExtractor.extract(
+                    output_file
+                )
+            elif uargs.intensities == 'semi-classical':
+                all_datasets = oe.XESSemiClassicalDipoleExtractor.extract(
+                    output_file
+                )
+        else:
+            ut.red_exit(
+                'Orca version < 6 not supported for XES spectrum generation'
             )
-    elif version[0] < 6:
-        ut.red_exit('Unsupported version of Orca for XES extraction', 'red')
 
-    ut.cprint('Using intensities: {}'.format(uargs.intensities), 'cyan')
+        ut.cprint('Using intensities: {}'.format(uargs.intensities), 'cyan')
 
-    # Plot each section
-    for it, data in enumerate(all_data):
+        # Create absorption data object
+        # one per dataset extracted
+        # (doubtful multiple datasets will be present, but just in case)
+        all_abs_data = [
+            d.AbsorptionData.from_extractor_dataset(
+                dataset,
+                uargs.intensities,
+                remove_zero_osc=uargs.zero_osc
+            )
+            for dataset in all_datasets
+        ]
 
-        if len(all_data) > 1:
-            save_name = f'emission_spectrum_section_{it:d}.png'
-        else:
-            save_name = 'emission_spectrum.png'
+        # Check absorption data was found
+        if len(all_abs_data) == 0:
+            ut.red_exit(
+                f'No ABSORPTION data found in file {output_file}', 'red'
+            )
+        # report if multiple absorption sections found
+        elif len(all_abs_data) > 1:
+            ut.cprint(
+                f'\nFound {len(all_abs_data)} ABSORPTION sections in '
+                f'file {output_file}\n'
+                f'Plotting final section ONLY\n',
+                'cyan'
+            )
+        # and only use final one
+        # (again, doubtful multiple sections will be present, but just in case)
+        abs_data = all_abs_data[-1]
 
+        # Determine x values for setting x limits of computed spectrum
         if uargs.x_unit == 'wavenumber':
-            x_values = np.asarray(data['energy (cm^-1)'])
+            x_vals = abs_data.wavenumbers
+            min_factor = 0.8
+            max_factor = 1.1
+            x_reversed = False
         elif uargs.x_unit == 'wavelength':
-            x_values = 1E7 / np.asarray(data['energy (cm^-1)'])
+            x_vals = abs_data.wavelengths
+            max_factor = 1.1
+            min_factor = 0.8
+            x_reversed = False
         elif uargs.x_unit == 'wavelength_rev':
-            x_values = 1E7 / np.asarray(data['energy (cm^-1)'])
+            x_vals = abs_data.wavelengths
+            max_factor = 1.1
+            min_factor = 0.8
+            x_reversed = True
+            uargs.x_unit = 'wavelength'
         elif uargs.x_unit == 'energy':
-            x_values = np.asarray(data['energy (ev)'])
-
-        data['fosc'] = np.asarray(data['fosc'])
-
-        # Remove transitions with zero oscillator strength from
-        # beginning and end of spectrum
-        if not uargs.no_trim:
-            # Find first non-zero oscillator strength
-            first_nonzero = np.where(data['fosc'] > 1E-6)[0][0]
-            # Find last non-zero oscillator strength
-            last_nonzero = np.where(data['fosc'] > 1E-6)[0][-1]
-
-            # Trim data
-            x_values = x_values[first_nonzero:last_nonzero + 1]
-            data['fosc'] = data['fosc'][first_nonzero:last_nonzero + 1]
-
-        # Plot emission spectrum
-        fig, ax = plotter.plot_abs(
-            x_values,
-            uargs.x_unit,
-            data['fosc'],
-            show=_SHOW_CONV[uargs.plot],
-            save=_SAVE_CONV[uargs.plot],
-            save_name=save_name,
-            xlim=uargs.xlim,
-            ylim=uargs.ylim,
-            x_shift=uargs.shift,
-            linewidth=uargs.linewidth,
+            x_vals = abs_data.energies
+            min_factor = 0.9995
+            max_factor = 1.0005
+            x_reversed = False
+
+        # Set x_min
+        # based on user arguments
+        if isinstance(uargs.xlim[0], str):
+            if uargs.xlim[0] == 'auto':
+                x_min = min(x_vals) * min_factor
+            elif ut.is_floatable(uargs.xlim[0]):
+                x_min = float(uargs.xlim[0])
+            else:
+                raise ValueError(f'Invalid x_min value: {uargs.xlim[0]}')
+        else:
+            x_min = uargs.xlim[0]
+
+        # Set x_max
+        # based on user arguments
+        if isinstance(uargs.xlim[1], str):
+            if uargs.xlim[1] == 'auto':
+                x_max = max(x_vals) * max_factor
+            elif ut.is_floatable(uargs.xlim[1]):
+                x_max = float(uargs.xlim[1])
+            else:
+                raise ValueError(f'Invalid x_max value: {uargs.xlim[1]}')
+        else:
+            x_max = uargs.xlim[1]
+
+        # Trim transitions to a specific number of states if requested
+        if uargs.trim_transitions is not None:
+            abs_data.trim_to_n(uargs.trim_transitions)
+
+        # Generate spectrum data
+        abs_data.generate_spectrum(
+            fwhm=uargs.linewidth,
             lineshape=uargs.lineshape,
-            window_title=f'Emission Spectrum from {uargs.output_file}',
+            x_type=uargs.x_unit,
+            num_points=10000,
+            x_min=x_min,
+            x_max=x_max,
+            comment=output_file,
+            x_reversed=x_reversed
+        )
+
+        # Save spectrum data to file
+        if save_data_only:
+            abs_data.save_spectrum_data(
+                f'absorption_spectrum_{output_file.stem}.csv',
+                comments='Data from {}\nfwhm={}, lineshape={}\nintensities={}'.format( # noqa
+                    output_file,
+                    uargs.linewidth,
+                    uargs.lineshape,
+                    uargs.intensities
+                )
+            )
+            abs_data.save_transition_data(
+                f'transition_data_{output_file.stem}.csv',
+                comments='Data from {}\nintensities={}'.format(
+                    output_file,
+                    uargs.intensities
+                )
+            )
+            ut.cprint(
+                f'Saved absorption spectrum to absorption_spectrum_{output_file.stem}.csv', # noqa
+                'cyan'
+            )
+            ut.cprint(
+                f'Saved absorption data to transition_data_{output_file.stem}.csv', # noqa
+                'cyan'
+            )
+        else:
+            # Add to dictionary of absorption data for plotting later
+            spectra_dict[output_file] = abs_data
+
+    # Exit if only saving data
+    if save_data_only:
+        return
+
+    # Plot all spectra
+    import matplotlib.pyplot as plt
+    import matplotlib.colors as mcolors
+
+    # Set font name and size
+    ut.check_font_envvar()
+    plt.rcParams['font.size'] = 10
+    plt.rcParams['legend.fontsize'] = 9
+    plt.rcParams['legend.loc'] = 'center right'
+
+    # Create list of colours for plotting
+    if len(uargs.output_file) == 1:
+        colours = ['black']
+    else:
+        colours = list(mcolors.TABLEAU_COLORS.values())
+
+    # Width of figure in inches
+    # Make wider if multiple spectra to plot
+    # to include legend
+    if len(spectra_dict) > 1:
+        width = 6.
+    else:
+        width = 4.
+    # width in cm
+    width_cm = 2.54 * width
+
+    # Create figure and axis with
+    # height based on golden ratio
+    golden = (1 + np.sqrt(5))/2
+    fig, ax = plt.subplots(
+        1,
+        1,
+        num='Absorption Spectrum',
+        figsize=(width, 4. / golden)
+    )
+    # Secondary axis for oscillator strength sticks
+    oax = ax.twinx()
+
+    # Plot absorption spectrum for each file
+    for it, (output_file, abs_data) in enumerate(spectra_dict.items()): # noqa
+
+        plotter.plot_absorption_spectrum(
+            abs_data,
+            linecolor=colours[it],
+            stickcolor=colours[it],
             osc_style=uargs.osc_style,
             normalise=uargs.normalise,
-            plot_type='emission'
+            window_title='',
+            fig=fig,
+            ax=ax,
+            oax=oax,
+            show=False,
+            save=False,
+            xlim=[x_min, x_max],
+            ylim=uargs.ylim,
+            x_shift=uargs.x_shift[it],
+            legend=False
         )
 
-        if uargs.x_unit == 'wavenumber':
-            ax[0].set_xlim([0, 50000])
+    if uargs.xlim != ['auto', 'auto']:
+        ax.set_xlim(float(uargs.xlim[0]), float(uargs.xlim[1]))
+
+    fig.tight_layout()
+
+    if len(spectra_dict) > 1:
+        fig.subplots_adjust(right=3.3/6.)
+        if uargs.legend is None:
+            legend_labels = [
+                f'{output_file.stem}' for output_file in spectra_dict.keys()
+            ]
+            fig.legend(legend_labels, loc=7)
+        else:
+            fig.legend(uargs.legend, loc=7)
+
+    if _SAVE_CONV[uargs.plot]:
+        savename = 'absorption_spectrum.png'
+        plt.savefig(savename, dpi=500)
+        ut.cprint(f'Saved image to {savename}', 'cyan')
+        ut.cprint(
+            f'Use width={width:.1f} in. or {width_cm:.1f} cm',
+            'cyan'
+        )
+
+    if _SHOW_CONV[uargs.plot]:
         plt.show()
 
+    return
+
 
 def plot_abs_func(uargs, save_data_only=False):
     '''
@@ -2781,6 +2948,132 @@ def read_args(arg_list=None):
         )
     )
 
+    gen_xes = gen_parser.add_parser(
+        'xes',
+        description='Generates XES data from SGS-DEF calculation output',
+        usage=ut.cstring('orto gen xes <output_file> [options]', 'cyan'),
+        formatter_class=argparse.RawTextHelpFormatter
+    )
+    gen_xes._positionals.title = 'Mandatory Arguments'
+
+    gen_xes.set_defaults(func=lambda x: plot_xes_func(x, save_data_only=True))
+
+    gen_xes.add_argument(
+        'output_file',
+        type=pathlib.Path,
+        nargs='+',
+        help='Orca output file name'
+    )
+
+    gen_xes.add_argument(
+        '--intensities',
+        '-i',
+        type=str,
+        choices=['velocity', 'electric', 'semi-classical'],
+        default='electric',
+        help='Type of intensity to plot (orca_mapspc uses electric)'
+    )
+
+    gen_xes.add_argument(
+        '--linewidth',
+        '-lw',
+        type=float,
+        default=1,
+        help=(
+            'Width of signal (FWHM for Gaussian, Width for Lorentzian),'
+            ' in same unit as x axis'
+        )
+    )
+
+    gen_xes.add_argument(
+        '--lineshape',
+        '-ls',
+        type=str,
+        choices=['gaussian', 'lorentzian'],
+        default='lorentzian',
+        help='Lineshape to use for each signal'
+    )
+
+    gen_xes.add_argument(
+        '--x_unit',
+        '-xu',
+        type=str,
+        choices=['energy', 'wavelength', 'wavenumber'],
+        default='energy',
+        help='x units to use for spectrum'
+    )
+
+    gen_xes.add_argument(
+        '--x_shift',
+        type=float,
+        default=None,
+        nargs='+',
+        help=(
+            'Shift spectrum by this amount in x units\n'
+            'Default: 0.'
+        )
+    )
+
+    gen_xes.add_argument(
+        '--no_trim',
+        action='store_true',
+        default=False,
+        help=(
+            'Do not trim spectrum to non-zero oscillator strength\n'
+            'Default: %(default)s'
+        )
+    )
+
+    gen_xes.add_argument(
+        '--xlim',
+        nargs=2,
+        default=['auto', 'auto'],
+        help='x limits of spectrum'
+    )
+
+    gen_xes.add_argument(
+        '--normalise',
+        '-n',
+        action='store_true',
+        default=False,
+        help=(
+            'Normalises spectrum to maximum value\n'
+            'Default: %(default)s'
+        )
+    )
+
+    gen_xes.add_argument(
+        '--zero_osc',
+        default=1E-7,
+        type=float,
+        help=(
+            'Oscillator strengths below this value are treated as zero\n'
+            'Default: %(default)s'
+        )
+    )
+
+    gen_xes.add_argument(
+        '--unique_names',
+        action='store_true',
+        default=False,
+        help=(
+            'Attempt to shorten file names in plot legend\n'
+            'Default: %(default)s'
+        )
+    )
+
+    gen_xes.add_argument(
+        '--trim_transitions',
+        '-tt',
+        type=int,
+        default=None,
+        help=(
+            'Trim to first n transitions\n'
+            'where n is an integer\n'
+            'Default: %(default)s'
+        )
+    )
+
     plot_subprog = all_subparsers.add_parser(
         'plot',
         description='Plot data from orca file',
@@ -2957,11 +3250,10 @@ def read_args(arg_list=None):
             'Default: %(default)s'
         )
     )
-
     plot_xes = plot_parser.add_parser(
         'xes',
-        description='Plots XES from CI calculation output',
-        usage=ut.cstring('orto plot xes <output_file>', 'cyan'),
+        description='Plots X-ray emission spectrum from SGS-DFT calculation output', # noqa
+        usage=ut.cstring('orto plot xes <output_file> [options]', 'cyan'),
         formatter_class=argparse.RawTextHelpFormatter
     )
     plot_xes._positionals.title = 'Mandatory Arguments'
@@ -2971,6 +3263,7 @@ def read_args(arg_list=None):
     plot_xes.add_argument(
         'output_file',
         type=pathlib.Path,
+        nargs='+',
         help='Orca output file name'
     )
 
@@ -2978,14 +3271,7 @@ def read_args(arg_list=None):
         '--intensities',
         '-i',
         type=str,
-        choices=[
-            'velocity',
-            'electric',
-            'semi-classical',
-            'so_velocity',
-            'so_electric',
-            'so_semi-classical',
-        ],
+        choices=['velocity', 'electric', 'semi-classical'],
         default='electric',
         help='Type of intensity to plot (orca_mapspc uses electric)'
     )
@@ -2994,17 +3280,17 @@ def read_args(arg_list=None):
         '--linewidth',
         '-lw',
         type=float,
-        default=2000,
+        default=1,
         help=(
             'Width of signal (FWHM for Gaussian, Width for Lorentzian),'
-            ' in Wavenumbers'
+            ' in same unit as x axis'
         )
     )
 
     plot_xes.add_argument(
         '--osc_style',
         type=str,
-        default='combined',
+        default='separate',
         help=(
             'Style of oscillators to plot\n'
             ' - \'separate\' plots oscillator strengths as stems on separate axis\n' # noqa
@@ -3042,29 +3328,21 @@ def read_args(arg_list=None):
 
     plot_xes.add_argument(
         '--x_unit',
+        '-xu',
         type=str,
-        choices=['wavenumber', 'energy', 'wavelength'],
-        default='wavenumber',
-        help='x units to use for spectrum'
+        choices=['energy', 'wavelength', 'wavelength_rev', 'wavenumber'],
+        default='energy',
+        help='x units to use for spectrum (rev = reversed axis direction)'
     )
 
     plot_xes.add_argument(
-        '--shift',
+        '--x_shift',
         type=float,
-        default=0.,
+        default=None,
+        nargs='+',
         help=(
             'Shift spectrum by this amount in x units\n'
-            'Default: %(default)s'
-        )
-    )
-
-    plot_xes.add_argument(
-        '--no_trim',
-        action='store_true',
-        default=False,
-        help=(
-            'Do not trim spectrum to non-zero oscillator strength\n'
-            'Default: %(default)s'
+            'Default: 0.'
         )
     )
 
@@ -3093,6 +3371,49 @@ def read_args(arg_list=None):
         )
     )
 
+    plot_xes.add_argument(
+        '--zero_osc',
+        default=1E-7,
+        type=float,
+        help=(
+            'Oscillator strengths below this value are treated as zero\n'
+            'Default: %(default)s'
+        )
+    )
+
+    plot_xes.add_argument(
+        '--legend',
+        type=str,
+        nargs='+',
+        default=None,
+        help=(
+            'Legend labels for each spectrum plotted\n'
+            'If not provided, file names are used\n'
+        )
+    )
+
+    plot_xes.add_argument(
+        '--trim_transitions',
+        '-tt',
+        type=int,
+        default=None,
+        help=(
+            'Trim to first n transitions\n'
+            'where n is an integer\n'
+            'Default: %(default)s'
+        )
+    )
+
+    plot_xes.add_argument(
+        '--no_trim',
+        action='store_true',
+        default=False,
+        help=(
+            'Do not trim spectrum to non-zero oscillator strength\n'
+            'Default: %(default)s'
+        )
+    )
+
     plot_ailft = plot_parser.add_parser(
         'ailft_orbs',
         aliases=['ailft_orb'],

orto/extractor.py

@@ -380,6 +380,81 @@ class ExchangeCouplingExtractor(extto.BetweenExtractor):
         return _ext.data
 
 
+class AILFTOrbMatrixExtractor(extto.BetweenExtractor):
+    '''
+    Extracts AI-LFT orbital matrix from Orca output file
+    '''
+    # Regex Start Pattern
+    START_PATTERN = rb'(?<=Ligand field one-electron matrix VLFT \(a.u.\) : )' # noqa
+
+    # Regex End Pattern
+    END_PATTERN = rb'(?=-------------------------------------------------)'
+
+    MODIFIERS = [re.MULTILINE]
+
+    @property
+    def data(self) -> list[NDArray]:
+        '''
+        AI-LFT matrices, one per block, in atomic units
+        '''
+        return self._data
+
+    @staticmethod
+    def _process_block(block: str) -> NDArray:
+        '''
+        Converts single block into data entries described in self.data
+
+        Parameters
+        ----------
+        block: str
+            String block extracted from file
+
+        Returns
+        -------
+        ndarray of floats
+            Keys described in self.data
+        '''
+
+        # Find number of orbitals from header of matrix
+        orb_list = re.findall(
+            r'Orbital[\sxyzd2f3\-]+\n',
+            block
+        )
+        n_orbs = len(orb_list[0].split()) - 1
+
+        rows = re.findall(
+            rf'((?:\s+\-?\d\.\d{{6}}){{{n_orbs:d}}})', # noqa
+            block
+        )
+
+        matrix = np.array([
+            [float(ve) for ve in row.split()]
+            for row in rows
+        ])
+
+        return matrix
+
+    @classmethod
+    def extract(cls, file_name: str | pathlib.Path) -> list[NDArray]: # noqa
+        '''
+        Convenience method which instantiates class, extracts blocks, and
+        returns processed datasets
+
+        Parameters
+        ----------
+        file_name: str | pathlib.Path
+            File to parse
+
+        Returns
+        -------
+        list[ndarray of floats]
+            Each entry contains processed data, as defined in cls.data
+        '''
+        _ext = cls()
+        _ext(file_name, process=True)
+        return _ext.data
+
+
 class AILFTOrbEnergyExtractor(extto.BetweenExtractor):
     '''
     Extracts AI-LFT orbital energies from Orca output file
@@ -1762,7 +1837,7 @@ class XESElectricDipoleExtractor(AbsorptionElectricDipoleExtractor):
     OPERATOR_TYPE = 'Electric Dipole'
 
     # Regex Start Pattern
-    START_PATTERN = rb'(?<=              X-RAY   EMISSION SPECTRUM VIA TRANSITION VELOCITY DIPOLE MOMENTS\s[\S\s]{408}\s)' # noqa
+    START_PATTERN = rb'(?<=              X-RAY   EMISSION SPECTRUM VIA TRANSITION ELECTRIC DIPOLE MOMENTS\s[\S\s]{408}\s)' # noqa
 
     # Regex End Pattern
     END_PATTERN = rb'(?=-{77})'
@@ -2292,7 +2367,7 @@ class StructureInputExtractor(extto.BetweenExtractor):
 
         # Get labels and coordinates
         all_info = re.findall(
-            r'([A-Za-z]+\s*-?\d\.\d*\s+-?\d\.\d*\s+-?\d\.\d*)',
+            r'([A-Za-z]+\s*-?\d*\.\d*\s+-?\d*\.\d*\s+-?\d*\.\d*)',
             block
         )
 

{orto-1.13.1.dist-info → orto-1.14.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orto
-Version: 1.13.1
+Version: 1.14.1
 Summary: A package to make life easier when performing Orca calculations.
 Home-page: https://orto.kragskow.group
 Author: Jon Kragskow

{orto-1.13.1.dist-info → orto-1.14.1.dist-info}/RECORD

@@ -1,17 +1,17 @@
 orto/__init__.py,sha256=IedlltYr3qYZxChNUdz62qogXA9Pos_MUvXdGXqAa0E,41
-orto/__version__.py,sha256=AWOJJXuaKFwrwxYimWHjFlOhtOJuGrGuiJ0JN7ehebE,23
-orto/cli.py,sha256=gBc8sSq9L3FXoYEyYxFQRMCCGtTEaVaGjePXOAnLM8Y,106677
+orto/__version__.py,sha256=eyARjsqZfiB7blnKzG-sgKU2HEsI143aQSUAfhkeA8U,23
+orto/cli.py,sha256=pyWz9CDKyoMyJtKlc68iW-9cZZc0VF6o44lmtvA4RC8,115549
 orto/constants.py,sha256=anxaiTykO8Q_CXliR7zuOAdnXZrQ2-C4ndaviyl7kGc,419
 orto/data.py,sha256=uHxgL-RIwQD61ZsrJPbrS0NBPDb3qIeLSbnpjlsPmiI,18225
 orto/exceptions.py,sha256=D7oNeAEGeJNt5thzt6PaCn5FY6JcbJOWUE1N1LVhhuE,159
-orto/extractor.py,sha256=nhrtzaeJtuU_SkMm201Z1ZqgHYnlsNfHxVOfVhs5plU,87484
+orto/extractor.py,sha256=PpaR9F7yW0cJIDuvuuJSbvqAftmlj9sZmgb7g91c0Wo,89391
 orto/input.py,sha256=uUQV6A-8D0GZpRoY1rKK_aUPmk9kVVTnMzTHuisP5t4,11888
 orto/job.py,sha256=tDiz9omFwinoYJamgz66MZez0Ee9HMhuCIAeHMhXRF8,5916
 orto/plotter.py,sha256=gw1oSPilWvUO__CjIq8gP9a8_Xq0078VE9porOPvhCc,19661
 orto/utils.py,sha256=2vMUQa_QPi7RbBdZN9EUara6A58GLZkJb9TfMTbBroU,11259
-orto-1.13.1.dist-info/licenses/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
-orto-1.13.1.dist-info/METADATA,sha256=k71QOiH_in85mH8YKiMRgSr2XTG_6O5ROqkHqxosiQ0,1185
-orto-1.13.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-orto-1.13.1.dist-info/entry_points.txt,sha256=HXenCglMp_03JkN34pK2phkjXK9CFcXTGHKv5QaVY8I,39
-orto-1.13.1.dist-info/top_level.txt,sha256=hQ-z28gTN_FZ2B5Kiwxr_9cUTcCoib9W5HjbkceDXw4,5
-orto-1.13.1.dist-info/RECORD,,
+orto-1.14.1.dist-info/licenses/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+orto-1.14.1.dist-info/METADATA,sha256=SIjGV-P2CGJOphlqcU2uPPSDh7ZGufEIbFJkoc5bMS4,1185
+orto-1.14.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+orto-1.14.1.dist-info/entry_points.txt,sha256=HXenCglMp_03JkN34pK2phkjXK9CFcXTGHKv5QaVY8I,39
+orto-1.14.1.dist-info/top_level.txt,sha256=hQ-z28gTN_FZ2B5Kiwxr_9cUTcCoib9W5HjbkceDXw4,5
+orto-1.14.1.dist-info/RECORD,,

{orto-1.13.1.dist-info → orto-1.14.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any