Source code for lasio

"""Lasio package for reading and writing Log Ascii Standard well files."""

import logging
import os

[docs]def add_logging_level(levelName, levelNum, methodName=None): """Add a new logging level to current logger. Comprehensively adds a new logging level to the `logging` module and the currently configured logging class. `levelName` becomes an attribute of the `logging` module with the value `levelNum`. `methodName` becomes a convenience method for both `logging` itself and the class returned by `logging.getLoggerClass()` (usually just `logging.Logger`). If `methodName` is not specified, `levelName.lower()` is used. To avoid accidental clobberings of existing attributes, this method will raise an `AttributeError` if the level name is already an attribute of the `logging` module or if the method name is already present Example >>> add_logging_level('TRACE', logging.DEBUG - 5) >>> logging.getLogger(__name__).setLevel("TRACE") >>> logging.getLogger(__name__).trace('that worked') >>> logging.trace('so did this') >>> logging.TRACE 5 """ if not methodName: methodName = levelName.lower() if hasattr(logging, levelName): raise AttributeError('{} already defined in logging module'.format(levelName)) if hasattr(logging, methodName): raise AttributeError('{} already defined in logging module'.format(methodName)) if hasattr(logging.getLoggerClass(), methodName): raise AttributeError('{} already defined in logger class'.format(methodName)) # This method was inspired by the answers to Stack Overflow post #, especially # def logForLevel(self, message, *args, **kwargs): if self.isEnabledFor(levelNum): self._log(levelNum, message, args, **kwargs) def logToRoot(message, *args, **kwargs): logging.log(levelNum, message, *args, **kwargs) logging.addLevelName(levelNum, levelName) setattr(logging, levelName, levelNum) setattr(logging.getLoggerClass(), methodName, logForLevel) setattr(logging, methodName, logToRoot)
add_logging_level("TRACE_LASIO", logging.DEBUG - 5, "trace_lasio") from .las_version import version from .las import LASFile, JSONEncoder from .las_items import CurveItem, HeaderItem, SectionItems from .reader import open_file __version__ = version()
[docs]def read(file_ref, **kwargs): """Read a LAS file. Note that only versions 1.2 and 2.0 of the LAS file specification are fully supported. There is partial support for reading LAS 3.0 files. Arguments: file_ref( :term:`file-like object` or :class:`str`): either a filename, an open file object, or a string containing the contents of a file. Keyword Arguments: ignore_header_errors (bool): ignore LASHeaderErrors (False by default) ignore_comments (sequence/str): ignore lines beginning with these characters e.g. ``("#", '"')`` in header sections. ignore_data_comments (str): ignore lines beginning with this character in data sections only. mnemonic_case (str): 'preserve': keep the case of HeaderItem mnemonics 'upper': convert all HeaderItem mnemonics to uppercase 'lower': convert all HeaderItem mnemonics to lowercase ignore_data (bool): if True, do not read in any of the actual data, just the header metadata. False by default. engine (str): "normal": parse data section with normal Python reader (quite slow); "numpy": parse data section with `numpy.genfromtxt` (fast). By default the engine is "numpy". use_normal_engine_for_wrapped (bool): if header metadata indicates that the file is wrapped, always use the 'normal' engine. Default is True. The only reason you should use False is if speed is a very high priority and you had files with metadata that incorrectly indicates they are wrapped. read_policy (str or list): Apply regular expression substitutions for common errors in fixed-width formatted data sections. If you do not want any such substitutions to applied, pass ``read_policy=()``. null_policy (str or list): see accept_regexp_sub_recommendations (bool): Accept recommendations to auto- matically remove read substitutions (applied by the default read_policy) which look for numeric run-on errors involving hyphens. This avoids incorrect parsing of dates such as '2018-05-22' as three separate columns containing '2018', '-5' and '-22'. The read substitutions are applied only if the inspection code of the data section finds a hyphen in every line. The only circumstance where this should be manually set to False is where you have very problematic fixed-column-width data sections involving negative values. index_unit (str): Optionally force-set the index curve's unit to "m" or "ft" dtypes ("auto", dict or list): specify the data types for each curve in the ~ASCII data section. If "auto", each curve will be converted to floats if possible and remain as str if not. If a dict you can specify only the curve mnemonics you want to convert as a key. If a list, please specify data types for each curve in order. Note that the conversion currently only occurs via numpy.ndarray.astype() and therefore only a few simple casts will work e.g. `int`, `float`, `str`. encoding (str): character encoding to open file_ref with, using :func:`` (this is handled by :func:`lasio.reader.open_with_codecs`) encoding_errors (str): 'strict', 'replace' (default), 'ignore' - how to handle errors with encodings (see `this section <>`__ of the standard library's :mod:`codecs` module for more information) (this is handled by :func:`lasio.reader.open_with_codecs`) autodetect_encoding (str or bool): default True to use `chardet <>`__ to detect encoding. Note if set to False several common encodings will be tried but chardet won't be used. (this is handled by :func:`lasio.reader.open_with_codecs`) autodetect_encoding_chars (int/None): number of chars to read from LAS file for auto-detection of encoding. (this is handled by :func:`lasio.reader.open_with_codecs`) Returns: a :class:`lasio.LASFile` object representing the file The documented arguments above are combined from these methods: * :func:`lasio.reader.open_with_codecs` - manage issues relate to character encodings * :meth:`` - control how NULL values and errors are handled during parsing """ return LASFile(file_ref, **kwargs)