mrpt.pymrpt.mrpt.system
index
(built-in)

Bindings for mrpt::system namespace

 
Modules
       
mrpt.pymrpt.mrpt.system.os

 
Classes
       
pybind11_builtins.pybind11_object(builtins.object)
CControlledRateTimer
CDirectoryExplorer
CFileSystemWatcher
CObservable
CObserver
COutputLoggerStreamWrapper
CRateTimer
CTicTac
CTimeLogger
CTimeLoggerEntry
CTimeLoggerSaveAtDtor
ConsoleBackgroundColor
ConsoleForegroundColor
ConsoleTextStyle
TProcessPriority
TThreadPriority
TTimeParts
VerbosityLevel
WorkerThreadsPool
mrptEvent
mrptEventOnDestroy

 
class CControlledRateTimer(pybind11_builtins.pybind11_object)
    A class for calling sleep() in a loop, such that the amount of sleep time
will be computed to make the loop run at the desired rate (in Hz).
This class implements a PI controller on top of a vanilla CRateTimer object,
ensuring a high accuracy in achieved execution rates. Note that this is done
by setting a slightly-higher rate ("control action") to the internal
CRateTimer, such that the error between the user-provided expected rate and
the actual measured rate (low-pass filtered) is decreased by means of a PI
controller.
 
Note that rates higher than a few kHz are not attainable in all CPUs and/or
kernel versions. Find below some graphs illustrating how this class tries to
achieve a constant setpoint rate (given by the user), reacting to changes in
the setpoint values:
 
 ![controlled rate timer plots](CControlledRateTimer_example.png)
 
This graphs is generated with the example:
 
`system_control_rate_timer_example --rate1 2000.0 --rate2 4000.0`
 
All the parameters for the PI controller and low-pass filter (rate estimator)
are settable by the user to adapt them to specific needs.
 
 
Control law by [Francisco Jose MaƱas
Alvarez](https://github.com/FranciscoJManasAlvarez)
 
 
[New in MRPT 2.0.4]
 
 
Method resolution order:
CControlledRateTimer
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.system.CControlledRateTimer) -> None
 
doc
 
2. __init__(self: mrpt.pymrpt.mrpt.system.CControlledRateTimer, rate_hz: float) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.system.CControlledRateTimer, arg0: mrpt.pymrpt.mrpt.system.CControlledRateTimer) -> None
actualControlledRate(...)
actualControlledRate(self: mrpt.pymrpt.mrpt.system.CControlledRateTimer) -> float
 
Gets the actual controller output: the rate (Hz) of the internal
 CRateTimer object. 
 
C++: mrpt::system::CControlledRateTimer::actualControlledRate() const --> double
assign(...)
assign(self: mrpt.pymrpt.mrpt.system.CControlledRateTimer, : mrpt.pymrpt.mrpt.system.CControlledRateTimer) -> mrpt.pymrpt.mrpt.system.CControlledRateTimer
 
C++: mrpt::system::CControlledRateTimer::operator=(const class mrpt::system::CControlledRateTimer &) --> class mrpt::system::CControlledRateTimer &
controllerParam_Kp(...)
controllerParam_Kp(*args, **kwargs)
Overloaded function.
 
1. controllerParam_Kp(self: mrpt.pymrpt.mrpt.system.CControlledRateTimer) -> float
 
PI controller Kp parameter [default=1.0] 
 
C++: mrpt::system::CControlledRateTimer::controllerParam_Kp() const --> double
 
2. controllerParam_Kp(self: mrpt.pymrpt.mrpt.system.CControlledRateTimer, v: float) -> None
 
C++: mrpt::system::CControlledRateTimer::controllerParam_Kp(double) --> void
controllerParam_Ti(...)
controllerParam_Ti(*args, **kwargs)
Overloaded function.
 
1. controllerParam_Ti(self: mrpt.pymrpt.mrpt.system.CControlledRateTimer) -> float
 
PI controller Ti parameter [default=0.0194] 
 
C++: mrpt::system::CControlledRateTimer::controllerParam_Ti() const --> double
 
2. controllerParam_Ti(self: mrpt.pymrpt.mrpt.system.CControlledRateTimer, v: float) -> None
 
C++: mrpt::system::CControlledRateTimer::controllerParam_Ti(double) --> void
estimatedRate(...)
estimatedRate(self: mrpt.pymrpt.mrpt.system.CControlledRateTimer) -> float
 
Gets the latest estimated run rate (Hz), which comes from actual period
 measurement, low-pass filtered. 
 
C++: mrpt::system::CControlledRateTimer::estimatedRate() const --> double
estimatedRateRaw(...)
estimatedRateRaw(self: mrpt.pymrpt.mrpt.system.CControlledRateTimer) -> float
 
Last actual execution rate measured (Hz), without low-pass filtering 
 
C++: mrpt::system::CControlledRateTimer::estimatedRateRaw() const --> double
followErrorRatioToRaiseWarning(...)
followErrorRatioToRaiseWarning(*args, **kwargs)
Overloaded function.
 
1. followErrorRatioToRaiseWarning(self: mrpt.pymrpt.mrpt.system.CControlledRateTimer) -> float
 
Get/set ratio threshold for issuing a warning (via COutputLogger
 interface) if the achieved rate is not this close to the set-point
 [Default=0.2, =20%]
 
C++: mrpt::system::CControlledRateTimer::followErrorRatioToRaiseWarning() const --> double
 
2. followErrorRatioToRaiseWarning(self: mrpt.pymrpt.mrpt.system.CControlledRateTimer, v: float) -> None
 
C++: mrpt::system::CControlledRateTimer::followErrorRatioToRaiseWarning(double) --> void
lowPassParam_a0(...)
lowPassParam_a0(*args, **kwargs)
Overloaded function.
 
1. lowPassParam_a0(self: mrpt.pymrpt.mrpt.system.CControlledRateTimer) -> float
 
Low-pass filter a0 value [default=0.9]:
 estimation = a0*input + (1-a0)*former_estimation 
 
C++: mrpt::system::CControlledRateTimer::lowPassParam_a0() const --> double
 
2. lowPassParam_a0(self: mrpt.pymrpt.mrpt.system.CControlledRateTimer, v: float) -> None
 
C++: mrpt::system::CControlledRateTimer::lowPassParam_a0(double) --> void
setRate(...)
setRate(self: mrpt.pymrpt.mrpt.system.CControlledRateTimer, rate_hz: float) -> None
 
Changes the object loop rate (Hz) 
 
C++: mrpt::system::CControlledRateTimer::setRate(const double) --> void
sleep(...)
sleep(self: mrpt.pymrpt.mrpt.system.CControlledRateTimer) -> bool
 
Sleeps for some time, such as the return of this method is 1/rate
 (seconds)
 after the return of the previous call.
 
 
 false if the rate could not be achieved ("we are already late"),
 true if all went right. 
 
C++: mrpt::system::CControlledRateTimer::sleep() --> bool

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CDirectoryExplorer(pybind11_builtins.pybind11_object)
    This class allows the enumeration of the files/directories that exist into a
given path.
 The only existing method is "explore" and returns the list of found files &
directories.
 Refer to the example in /samples/UTILS/directoryExplorer
 
 
CFileSystemWatcher
 
 
Method resolution order:
CDirectoryExplorer
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.system.CDirectoryExplorer) -> None

Static methods defined here:
explore(...) from builtins.PyCapsule
explore(*args, **kwargs)
Overloaded function.
 
1. explore(path: str, mask: int) -> List[mrpt::system::CDirectoryExplorer::TFileInfo]
 
The path of the directory to examine must be passed to this constructor,
 among the
  According to the following parameters, the object will collect the list
 of files, which
   can be modified later through other methods in this class.
 
 
 The path to examine (IT MUST BE A DIRECTORY), e.g
 "d:\temp\", or "/usr/include/"
 
 
 One or the OR'ed combination of the values
 "FILE_ATTRIB_ARCHIVE" and "FILE_ATTRIB_DIRECTORY", depending on what file
 types do you want in the list (These values are platform-independent).
 
 
 The list of found files/directories is stored here.
 
 
 sortByName
 
C++: mrpt::system::CDirectoryExplorer::explore(const std::string &, const unsigned long) --> class std::deque<struct mrpt::system::CDirectoryExplorer::TFileInfo>
 
2. explore(path: str, mask: int, outList: List[mrpt::system::CDirectoryExplorer::TFileInfo]) -> None
 
C++: mrpt::system::CDirectoryExplorer::explore(const std::string &, const unsigned long, class std::deque<struct mrpt::system::CDirectoryExplorer::TFileInfo> &) --> void
filterByExtension(...) from builtins.PyCapsule
filterByExtension(lstFiles: List[mrpt::system::CDirectoryExplorer::TFileInfo], extension: str) -> None
 
Remove from the list of files those whose extension does not coincide
 (without case) with the given one.
  Example:  filterByExtension(lst,"txt");
 
C++: mrpt::system::CDirectoryExplorer::filterByExtension(class std::deque<struct mrpt::system::CDirectoryExplorer::TFileInfo> &, const std::string &) --> void
sortByName(...) from builtins.PyCapsule
sortByName(*args, **kwargs)
Overloaded function.
 
1. sortByName(lstFiles: List[mrpt::system::CDirectoryExplorer::TFileInfo]) -> None
 
2. sortByName(lstFiles: List[mrpt::system::CDirectoryExplorer::TFileInfo], ascendingOrder: bool) -> None
 
Sort the file entries by name, in ascending or descending order
 
C++: mrpt::system::CDirectoryExplorer::sortByName(class std::deque<struct mrpt::system::CDirectoryExplorer::TFileInfo> &, bool) --> void

Data and other attributes defined here:
TFileInfo = <class 'mrpt.pymrpt.mrpt.system.CDirectoryExplorer.TFileInfo'>
This represents the information about each file.

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CFileSystemWatcher(pybind11_builtins.pybind11_object)
    This class subscribes to notifications of file system changes, thus it can
be used to efficiently stay informed about changes in a directory tree.
 - Windows: Requires Windows 2000 or newer.
 - Linux: Requires kernel 2.6.13 or newer.
 Using this class in an old Linux or other unsoported system (Unix,etc...)
has no effect, i.e. no notification will be ever received.
 
 
CDirectoryExplorer
 
 
Method resolution order:
CFileSystemWatcher
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.system.CFileSystemWatcher, path: str) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.system.CFileSystemWatcher, arg0: mrpt.pymrpt.mrpt.system.CFileSystemWatcher) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.system.CFileSystemWatcher, : mrpt.pymrpt.mrpt.system.CFileSystemWatcher) -> mrpt.pymrpt.mrpt.system.CFileSystemWatcher
 
C++: mrpt::system::CFileSystemWatcher::operator=(const class mrpt::system::CFileSystemWatcher &) --> class mrpt::system::CFileSystemWatcher &

Data and other attributes defined here:
TFileSystemChange = <class 'mrpt.pymrpt.mrpt.system.CFileSystemWatcher.TFileSystemChange'>
Each of the changes detected by mrpt::system::CFileSystemWatcher

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CObservable(pybind11_builtins.pybind11_object)
    Inherit from this class for those objects capable of being observed by a
CObserver class.
 
 The only thing to do in your child class is to call
CObservable::publishEvent() whenever needed and all the
  observer classes will be notified.
 
 
The pairs CObservable / CObserver automatically notify each other the
destruction of any of them, effectively ending the subscription of events.
 
 
CObservermrptEvent
 
 
Method resolution order:
CObservable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.system.CObservable) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.system.CObservable, arg0: mrpt.pymrpt.mrpt.system.CObservable) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.system.CObservable, : mrpt.pymrpt.mrpt.system.CObservable) -> mrpt.pymrpt.mrpt.system.CObservable
 
C++: mrpt::system::CObservable::operator=(const class mrpt::system::CObservable &) --> class mrpt::system::CObservable &

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CObserver(pybind11_builtins.pybind11_object)
    Inherit from this class to get notified about events from any CObservable
object after subscribing to it.
 
 The main methods in this class are:
  - observeBegin(): To be called to start listening at a given object.
  - OnEvent(): Virtual functions to be implemented in your child class to
receive all the notifications.
 
 Note that if custom (child) mrptEvent classes are used, you can tell
between them in runtime with "dynamic_cast<>()".
 
 
The pairs CObservable / CObserver automatically notify each other the
destruction of any of them, effectively ending the subscription of events.
 
 
 
 
CObservablemrptEvent
 
 
Method resolution order:
CObserver
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.system.CObserver) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.system.CObserver, arg0: mrpt.pymrpt.mrpt.system.CObserver) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.system.CObserver, : mrpt.pymrpt.mrpt.system.CObserver) -> mrpt.pymrpt.mrpt.system.CObserver
 
C++: mrpt::system::CObserver::operator=(const class mrpt::system::CObserver &) --> class mrpt::system::CObserver &
observeBegin(...)
observeBegin(self: mrpt.pymrpt.mrpt.system.CObserver, obj: mrpt.pymrpt.mrpt.system.CObservable) -> None
 
Starts the subscription of this observer to the given object.  
 
 observeEnd  
 
C++: mrpt::system::CObserver::observeBegin(class mrpt::system::CObservable &) --> void
observeEnd(...)
observeEnd(self: mrpt.pymrpt.mrpt.system.CObserver, obj: mrpt.pymrpt.mrpt.system.CObservable) -> None
 
Ends the subscription of this observer to the given object (note that
           there is no need to call this method, since the destruction of the first
           of observer/observed will put an end to the process
                
 
 observeBegin  
 
C++: mrpt::system::CObserver::observeEnd(class mrpt::system::CObservable &) --> void

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class COutputLoggerStreamWrapper(pybind11_builtins.pybind11_object)
    For use in MRPT_LOG_DEBUG_STREAM(), etc.
 
 
Method resolution order:
COutputLoggerStreamWrapper
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CRateTimer(pybind11_builtins.pybind11_object)
    A class for calling sleep() in a loop, such that the amount of sleep time
will be computed to make the loop run at the desired rate (in Hz).
 
 
Method resolution order:
CRateTimer
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.system.CRateTimer) -> None
 
doc
 
2. __init__(self: mrpt.pymrpt.mrpt.system.CRateTimer, rate_hz: float) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.system.CRateTimer, arg0: mrpt.pymrpt.mrpt.system.CRateTimer) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.system.CRateTimer, : mrpt.pymrpt.mrpt.system.CRateTimer) -> mrpt.pymrpt.mrpt.system.CRateTimer
 
C++: mrpt::system::CRateTimer::operator=(const class mrpt::system::CRateTimer &) --> class mrpt::system::CRateTimer &
rate(...)
rate(self: mrpt.pymrpt.mrpt.system.CRateTimer) -> float
 
Gets current rate (Hz) 
 
C++: mrpt::system::CRateTimer::rate() const --> double
setRate(...)
setRate(self: mrpt.pymrpt.mrpt.system.CRateTimer, rate_hz: float) -> None
 
Changes the object loop rate (Hz) 
 
C++: mrpt::system::CRateTimer::setRate(const double) --> void
sleep(...)
sleep(self: mrpt.pymrpt.mrpt.system.CRateTimer) -> bool
 
Sleeps for some time, such as the return of this method is 1/rate
 (seconds)
 after the return of the previous call.
 
 
 false if the rate could not be achieved ("we are already late"),
 true if all went right. 
 
C++: mrpt::system::CRateTimer::sleep() --> bool

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CTicTac(pybind11_builtins.pybind11_object)
    A high-performance stopwatch, with typical resolution of nanoseconds.
 
This always uses the system MONOTONIC clock, despite the setting in
mrpt::Clock.
 
 
The class is named after the Spanish equivalent of "Tic-Toc" ;-)
 
 
Method resolution order:
CTicTac
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
Tac(...)
Tac(self: mrpt.pymrpt.mrpt.system.CTicTac) -> float
 
Stops the stopwatch.  
 Returns the ellapsed time in seconds.
 
 
 Tic() 
 
C++: mrpt::system::CTicTac::Tac() const --> double
Tic(...)
Tic(self: mrpt.pymrpt.mrpt.system.CTicTac) -> None
 
Starts the stopwatch. 
 Tac() 
 
C++: mrpt::system::CTicTac::Tic() --> void
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.system.CTicTac) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.system.CTicTac, arg0: mrpt.pymrpt.mrpt.system.CTicTac) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.system.CTicTac, : mrpt.pymrpt.mrpt.system.CTicTac) -> mrpt.pymrpt.mrpt.system.CTicTac
 
C++: mrpt::system::CTicTac::operator=(const class mrpt::system::CTicTac &) --> class mrpt::system::CTicTac &

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CTimeLogger(pybind11_builtins.pybind11_object)
    A versatile "profiler" that logs the time spent within each pair of calls to
enter(X)-leave(X), among other stats.
 The results can be dumped to cout or to Visual Studio's output panel.
This class can be also used to monitorize min/mean/max/total stats of any
user-provided parameters via the method CTimeLogger::registerUserMeasure().
 
Optional recording of **all** data can be enabled via
enableKeepWholeHistory() (use with caution!).
 
Cost of the profiler itself (measured on MSVC2015, Windows 10, Intel i5-2310
2.9GHz):
- `enter()`: average 445 ns
- `leave()`: average 316 ns
 
 Recursive methods are supported with no problems, that is, calling "enter(X)
enter(X) ... leave(X) leave(X)".
 `enter()`/`leave()` are thread-safe, in the sense of they being safe to be
called from different threads. However, calling `enter()`/`leave()` for the
same user-supplied "section name", from different threads, is not allowed. In
the latter case (and, actually, in general since it's safer against
exceptions), use the RAII helper class CTimeLoggerEntry.
 
 
CTimeLoggerEntry
 
 
The default behavior is dumping all the information at destruction.
 
 
Method resolution order:
CTimeLogger
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.system.CTimeLogger) -> None
 
doc
 
2. __init__(self: mrpt.pymrpt.mrpt.system.CTimeLogger, enabled: bool) -> None
 
doc
 
3. __init__(self: mrpt.pymrpt.mrpt.system.CTimeLogger, enabled: bool, name: str) -> None
 
doc
 
4. __init__(self: mrpt.pymrpt.mrpt.system.CTimeLogger, enabled: bool, name: str, keep_whole_history: bool) -> None
 
5. __init__(self: mrpt.pymrpt.mrpt.system.CTimeLogger, arg0: mrpt.pymrpt.mrpt.system.CTimeLogger) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.system.CTimeLogger, o: mrpt.pymrpt.mrpt.system.CTimeLogger) -> mrpt.pymrpt.mrpt.system.CTimeLogger
 
C++: mrpt::system::CTimeLogger::operator=(const class mrpt::system::CTimeLogger &) --> class mrpt::system::CTimeLogger &
clear(...)
clear(*args, **kwargs)
Overloaded function.
 
1. clear(self: mrpt.pymrpt.mrpt.system.CTimeLogger) -> None
 
2. clear(self: mrpt.pymrpt.mrpt.system.CTimeLogger, deep_clear: bool) -> None
 
Resets all stats. By default (deep_clear=false), all section names are
 remembered (not freed) so the cost of creating upon the first next call
 is avoided.
 
 
 By design, calling this method is the only one which is not thread
 safe. It's not made thread-safe to save the performance cost. Please,
 ensure that you call `clear()` only while there are no other threads
 registering annotations in the object.
 
C++: mrpt::system::CTimeLogger::clear(bool) --> void
disable(...)
disable(self: mrpt.pymrpt.mrpt.system.CTimeLogger) -> None
 
C++: mrpt::system::CTimeLogger::disable() --> void
dumpAllStats(...)
dumpAllStats(*args, **kwargs)
Overloaded function.
 
1. dumpAllStats(self: mrpt.pymrpt.mrpt.system.CTimeLogger) -> None
 
2. dumpAllStats(self: mrpt.pymrpt.mrpt.system.CTimeLogger, column_width: int) -> None
 
Dump all stats through the COutputLogger interface. 
 getStatsAsText,
 saveToCVSFile 
 
C++: mrpt::system::CTimeLogger::dumpAllStats(size_t) const --> void
enable(...)
enable(*args, **kwargs)
Overloaded function.
 
1. enable(self: mrpt.pymrpt.mrpt.system.CTimeLogger) -> None
 
2. enable(self: mrpt.pymrpt.mrpt.system.CTimeLogger, enabled: bool) -> None
 
C++: mrpt::system::CTimeLogger::enable(bool) --> void
enableKeepWholeHistory(...)
enableKeepWholeHistory(*args, **kwargs)
Overloaded function.
 
1. enableKeepWholeHistory(self: mrpt.pymrpt.mrpt.system.CTimeLogger) -> None
 
2. enableKeepWholeHistory(self: mrpt.pymrpt.mrpt.system.CTimeLogger, enable: bool) -> None
 
C++: mrpt::system::CTimeLogger::enableKeepWholeHistory(bool) --> void
getLastTime(...)
getLastTime(self: mrpt.pymrpt.mrpt.system.CTimeLogger, name: str) -> float
 
Return the last execution time of the given "section", or 0 if it hasn't
 ever been called "enter" with that section name 
 
C++: mrpt::system::CTimeLogger::getLastTime(const std::string &) const --> double
getMeanTime(...)
getMeanTime(self: mrpt.pymrpt.mrpt.system.CTimeLogger, name: str) -> float
 
Return the mean execution time of the given "section", or 0 if it hasn't
 ever been called "enter" with that section name 
 
C++: mrpt::system::CTimeLogger::getMeanTime(const std::string &) const --> double
getName(...)
getName(self: mrpt.pymrpt.mrpt.system.CTimeLogger) -> str
 
C++: mrpt::system::CTimeLogger::getName() const --> const std::string &
getStatsAsText(...)
getStatsAsText(*args, **kwargs)
Overloaded function.
 
1. getStatsAsText(self: mrpt.pymrpt.mrpt.system.CTimeLogger) -> str
 
2. getStatsAsText(self: mrpt.pymrpt.mrpt.system.CTimeLogger, column_width: int) -> str
 
Dump all stats to a multi-line text string. 
 dumpAllStats,
 saveToCVSFile 
 
C++: mrpt::system::CTimeLogger::getStatsAsText(size_t) const --> std::string
isEnabled(...)
isEnabled(self: mrpt.pymrpt.mrpt.system.CTimeLogger) -> bool
 
C++: mrpt::system::CTimeLogger::isEnabled() const --> bool
isEnabledKeepWholeHistory(...)
isEnabledKeepWholeHistory(self: mrpt.pymrpt.mrpt.system.CTimeLogger) -> bool
 
C++: mrpt::system::CTimeLogger::isEnabledKeepWholeHistory() const --> bool
saveToCSVFile(...)
saveToCSVFile(self: mrpt.pymrpt.mrpt.system.CTimeLogger, csv_file: str) -> None
 
Dump all stats to a Comma Separated Values (CSV) file. 
 dumpAllStats
 
C++: mrpt::system::CTimeLogger::saveToCSVFile(const std::string &) const --> void
saveToMFile(...)
saveToMFile(self: mrpt.pymrpt.mrpt.system.CTimeLogger, m_file: str) -> None
 
Dump all stats to a Matlab/Octave (.m) file. 
 dumpAllStats 
 
C++: mrpt::system::CTimeLogger::saveToMFile(const std::string &) const --> void
setName(...)
setName(self: mrpt.pymrpt.mrpt.system.CTimeLogger, name: str) -> None
 
C++: mrpt::system::CTimeLogger::setName(const std::string &) --> void

Data and other attributes defined here:
TCallStats = <class 'mrpt.pymrpt.mrpt.system.CTimeLogger.TCallStats'>
Data of each call section: # of calls, minimum, maximum, average and
overall execution time (in seconds) 
 
getStats

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CTimeLoggerEntry(pybind11_builtins.pybind11_object)
    A safe way to call enter() and leave() of a mrpt::system::CTimeLogger upon
construction and destruction of
this auxiliary object, making sure that leave() will be called upon
exceptions, etc.
Usage mode #1 (scoped):
 
 
 
 
 
 
 
 
 
 
 
 
Usage mode #2 (unscoped):
 
 
Method resolution order:
CTimeLoggerEntry
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.system.CTimeLoggerEntry, arg0: mrpt.pymrpt.mrpt.system.CTimeLoggerEntry) -> None
stop(...)
stop(self: mrpt.pymrpt.mrpt.system.CTimeLoggerEntry) -> None
 
C++: mrpt::system::CTimeLoggerEntry::stop() --> void

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CTimeLoggerSaveAtDtor(pybind11_builtins.pybind11_object)
    A helper class to save CSV stats upon self destruction, for example, at the
end of a program run. The target file will be named after timelogger's name.
 
 
Method resolution order:
CTimeLoggerSaveAtDtor
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.system.CTimeLoggerSaveAtDtor, tm: mrpt.pymrpt.mrpt.system.CTimeLogger) -> None

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class ConsoleBackgroundColor(pybind11_builtins.pybind11_object)
    
Method resolution order:
ConsoleBackgroundColor
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__eq__(...)
__eq__(self: object, other: object) -> bool
__getstate__(...)
__getstate__(self: object) -> int
__hash__(...)
__hash__(self: object) -> int
__index__(...)
__index__(self: mrpt.pymrpt.mrpt.system.ConsoleBackgroundColor) -> int
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.system.ConsoleBackgroundColor, value: int) -> None
__int__(...)
__int__(self: mrpt.pymrpt.mrpt.system.ConsoleBackgroundColor) -> int
__ne__(...)
__ne__(self: object, other: object) -> bool
__repr__(...)
__repr__(self: object) -> str
__setstate__(...)
__setstate__(self: mrpt.pymrpt.mrpt.system.ConsoleBackgroundColor, state: int) -> None
__str__ = name(...)
name(self: handle) -> str

Readonly properties defined here:
__members__
name
name(self: handle) -> str
value

Data and other attributes defined here:
BLACK = <ConsoleBackgroundColor.BLACK: 40>
BLUE = <ConsoleBackgroundColor.BLUE: 44>
BRIGHT_BLACK = <ConsoleBackgroundColor.BRIGHT_BLACK: 100>
BRIGHT_BLUE = <ConsoleBackgroundColor.BRIGHT_BLUE: 104>
BRIGHT_CYAN = <ConsoleBackgroundColor.BRIGHT_CYAN: 106>
BRIGHT_GREEN = <ConsoleBackgroundColor.BRIGHT_GREEN: 102>
BRIGHT_MAGENTA = <ConsoleBackgroundColor.BRIGHT_MAGENTA: 105>
BRIGHT_RED = <ConsoleBackgroundColor.BRIGHT_RED: 101>
BRIGHT_WHITE = <ConsoleBackgroundColor.BRIGHT_WHITE: 107>
BRIGHT_YELLOW = <ConsoleBackgroundColor.BRIGHT_YELLOW: 103>
CYAN = <ConsoleBackgroundColor.CYAN: 46>
DEFAULT = <ConsoleBackgroundColor.DEFAULT: 0>
GREEN = <ConsoleBackgroundColor.GREEN: 42>
MAGENTA = <ConsoleBackgroundColor.MAGENTA: 45>
RED = <ConsoleBackgroundColor.RED: 41>
WHITE = <ConsoleBackgroundColor.WHITE: 34>
YELLOW = <ConsoleBackgroundColor.YELLOW: 43>

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class ConsoleForegroundColor(pybind11_builtins.pybind11_object)
    
Method resolution order:
ConsoleForegroundColor
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__eq__(...)
__eq__(self: object, other: object) -> bool
__getstate__(...)
__getstate__(self: object) -> int
__hash__(...)
__hash__(self: object) -> int
__index__(...)
__index__(self: mrpt.pymrpt.mrpt.system.ConsoleForegroundColor) -> int
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.system.ConsoleForegroundColor, value: int) -> None
__int__(...)
__int__(self: mrpt.pymrpt.mrpt.system.ConsoleForegroundColor) -> int
__ne__(...)
__ne__(self: object, other: object) -> bool
__repr__(...)
__repr__(self: object) -> str
__setstate__(...)
__setstate__(self: mrpt.pymrpt.mrpt.system.ConsoleForegroundColor, state: int) -> None
__str__ = name(...)
name(self: handle) -> str

Readonly properties defined here:
__members__
name
name(self: handle) -> str
value

Data and other attributes defined here:
BLACK = <ConsoleForegroundColor.BLACK: 30>
BLUE = <ConsoleForegroundColor.BLUE: 34>
BRIGHT_BLACK = <ConsoleForegroundColor.BRIGHT_BLACK: 90>
BRIGHT_BLUE = <ConsoleForegroundColor.BRIGHT_BLUE: 94>
BRIGHT_CYAN = <ConsoleForegroundColor.BRIGHT_CYAN: 96>
BRIGHT_GREEN = <ConsoleForegroundColor.BRIGHT_GREEN: 92>
BRIGHT_MAGENTA = <ConsoleForegroundColor.BRIGHT_MAGENTA: 95>
BRIGHT_RED = <ConsoleForegroundColor.BRIGHT_RED: 91>
BRIGHT_WHITE = <ConsoleForegroundColor.BRIGHT_WHITE: 97>
BRIGHT_YELLOW = <ConsoleForegroundColor.BRIGHT_YELLOW: 93>
CYAN = <ConsoleForegroundColor.CYAN: 36>
DEFAULT = <ConsoleForegroundColor.DEFAULT: 0>
GREEN = <ConsoleForegroundColor.GREEN: 32>
MAGENTA = <ConsoleForegroundColor.MAGENTA: 35>
RED = <ConsoleForegroundColor.RED: 31>
WHITE = <ConsoleForegroundColor.WHITE: 37>
YELLOW = <ConsoleForegroundColor.YELLOW: 33>

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class ConsoleTextStyle(pybind11_builtins.pybind11_object)
    
Method resolution order:
ConsoleTextStyle
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__eq__(...)
__eq__(self: object, other: object) -> bool
__getstate__(...)
__getstate__(self: object) -> int
__hash__(...)
__hash__(self: object) -> int
__index__(...)
__index__(self: mrpt.pymrpt.mrpt.system.ConsoleTextStyle) -> int
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.system.ConsoleTextStyle, value: int) -> None
__int__(...)
__int__(self: mrpt.pymrpt.mrpt.system.ConsoleTextStyle) -> int
__ne__(...)
__ne__(self: object, other: object) -> bool
__repr__(...)
__repr__(self: object) -> str
__setstate__(...)
__setstate__(self: mrpt.pymrpt.mrpt.system.ConsoleTextStyle, state: int) -> None
__str__ = name(...)
name(self: handle) -> str

Readonly properties defined here:
__members__
name
name(self: handle) -> str
value

Data and other attributes defined here:
BLINKING = <ConsoleTextStyle.BLINKING: 5>
BOLD = <ConsoleTextStyle.BOLD: 1>
DIM = <ConsoleTextStyle.DIM: 2>
INVISIBLE = <ConsoleTextStyle.INVISIBLE: 8>
ITALIC = <ConsoleTextStyle.ITALIC: 3>
REGULAR = <ConsoleTextStyle.REGULAR: 0>
REVERSE = <ConsoleTextStyle.REVERSE: 7>
UNDERLINED = <ConsoleTextStyle.UNDERLINED: 4>

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class TProcessPriority(pybind11_builtins.pybind11_object)
    
Method resolution order:
TProcessPriority
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__and__(...)
__and__(self: object, other: object) -> object
__eq__(...)
__eq__(self: object, other: object) -> bool
__ge__(...)
__ge__(self: object, other: object) -> bool
__getstate__(...)
__getstate__(self: object) -> int
__gt__(...)
__gt__(self: object, other: object) -> bool
__hash__(...)
__hash__(self: object) -> int
__index__(...)
__index__(self: mrpt.pymrpt.mrpt.system.TProcessPriority) -> int
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.system.TProcessPriority, value: int) -> None
__int__(...)
__int__(self: mrpt.pymrpt.mrpt.system.TProcessPriority) -> int
__invert__(...)
__invert__(self: object) -> object
__le__(...)
__le__(self: object, other: object) -> bool
__lt__(...)
__lt__(self: object, other: object) -> bool
__ne__(...)
__ne__(self: object, other: object) -> bool
__or__(...)
__or__(self: object, other: object) -> object
__rand__(...)
__rand__(self: object, other: object) -> object
__repr__(...)
__repr__(self: object) -> str
__ror__(...)
__ror__(self: object, other: object) -> object
__rxor__(...)
__rxor__(self: object, other: object) -> object
__setstate__(...)
__setstate__(self: mrpt.pymrpt.mrpt.system.TProcessPriority, state: int) -> None
__str__ = name(...)
name(self: handle) -> str
__xor__(...)
__xor__(self: object, other: object) -> object

Readonly properties defined here:
__members__
name
name(self: handle) -> str
value

Data and other attributes defined here:
ppHigh = <TProcessPriority.ppHigh: 2>
ppIdle = <TProcessPriority.ppIdle: 0>
ppNormal = <TProcessPriority.ppNormal: 1>
ppVeryHigh = <TProcessPriority.ppVeryHigh: 3>

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class TThreadPriority(pybind11_builtins.pybind11_object)
    
Method resolution order:
TThreadPriority
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__and__(...)
__and__(self: object, other: object) -> object
__eq__(...)
__eq__(self: object, other: object) -> bool
__ge__(...)
__ge__(self: object, other: object) -> bool
__getstate__(...)
__getstate__(self: object) -> int
__gt__(...)
__gt__(self: object, other: object) -> bool
__hash__(...)
__hash__(self: object) -> int
__index__(...)
__index__(self: mrpt.pymrpt.mrpt.system.TThreadPriority) -> int
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.system.TThreadPriority, value: int) -> None
__int__(...)
__int__(self: mrpt.pymrpt.mrpt.system.TThreadPriority) -> int
__invert__(...)
__invert__(self: object) -> object
__le__(...)
__le__(self: object, other: object) -> bool
__lt__(...)
__lt__(self: object, other: object) -> bool
__ne__(...)
__ne__(self: object, other: object) -> bool
__or__(...)
__or__(self: object, other: object) -> object
__rand__(...)
__rand__(self: object, other: object) -> object
__repr__(...)
__repr__(self: object) -> str
__ror__(...)
__ror__(self: object, other: object) -> object
__rxor__(...)
__rxor__(self: object, other: object) -> object
__setstate__(...)
__setstate__(self: mrpt.pymrpt.mrpt.system.TThreadPriority, state: int) -> None
__str__ = name(...)
name(self: handle) -> str
__xor__(...)
__xor__(self: object, other: object) -> object

Readonly properties defined here:
__members__
name
name(self: handle) -> str
value

Data and other attributes defined here:
tpHigh = <TThreadPriority.tpHigh: 1>
tpHigher = <TThreadPriority.tpHigher: 2>
tpHighest = <TThreadPriority.tpHighest: 15>
tpLow = <TThreadPriority.tpLow: -1>
tpLower = <TThreadPriority.tpLower: -2>
tpLowests = <TThreadPriority.tpLowests: -15>
tpNormal = <TThreadPriority.tpNormal: 0>

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class TTimeParts(pybind11_builtins.pybind11_object)
    The parts of a date/time, like the standard `tm` but with fractional
(`double`) seconds. 
 
TTimeStamp, timestampToParts, buildTimestampFromParts
 
 
Method resolution order:
TTimeParts
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.system.TTimeParts) -> None

Data descriptors defined here:
day
day_of_week
daylight_saving
hour
minute
month
second
year

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class VerbosityLevel(pybind11_builtins.pybind11_object)
    
Method resolution order:
VerbosityLevel
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__and__(...)
__and__(self: object, other: object) -> object
__eq__(...)
__eq__(self: object, other: object) -> bool
__ge__(...)
__ge__(self: object, other: object) -> bool
__getstate__(...)
__getstate__(self: object) -> int
__gt__(...)
__gt__(self: object, other: object) -> bool
__hash__(...)
__hash__(self: object) -> int
__index__(...)
__index__(self: mrpt.pymrpt.mrpt.system.VerbosityLevel) -> int
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.system.VerbosityLevel, value: int) -> None
__int__(...)
__int__(self: mrpt.pymrpt.mrpt.system.VerbosityLevel) -> int
__invert__(...)
__invert__(self: object) -> object
__le__(...)
__le__(self: object, other: object) -> bool
__lt__(...)
__lt__(self: object, other: object) -> bool
__ne__(...)
__ne__(self: object, other: object) -> bool
__or__(...)
__or__(self: object, other: object) -> object
__rand__(...)
__rand__(self: object, other: object) -> object
__repr__(...)
__repr__(self: object) -> str
__ror__(...)
__ror__(self: object, other: object) -> object
__rxor__(...)
__rxor__(self: object, other: object) -> object
__setstate__(...)
__setstate__(self: mrpt.pymrpt.mrpt.system.VerbosityLevel, state: int) -> None
__str__ = name(...)
name(self: handle) -> str
__xor__(...)
__xor__(self: object, other: object) -> object

Readonly properties defined here:
__members__
name
name(self: handle) -> str
value

Data and other attributes defined here:
LVL_DEBUG = <VerbosityLevel.LVL_DEBUG: 0>
LVL_ERROR = <VerbosityLevel.LVL_ERROR: 3>
LVL_INFO = <VerbosityLevel.LVL_INFO: 1>
LVL_WARN = <VerbosityLevel.LVL_WARN: 2>
NUMBER_OF_VERBOSITY_LEVELS = <VerbosityLevel.NUMBER_OF_VERBOSITY_LEVELS: 4>

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class WorkerThreadsPool(pybind11_builtins.pybind11_object)
    A simple thread pool
 
 
Partly based on: https://github.com/progschj/ThreadPool (ZLib license)
 
 
Method resolution order:
WorkerThreadsPool
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.system.WorkerThreadsPool) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.system.WorkerThreadsPool, num_threads: int) -> None
 
doc
 
3. __init__(self: mrpt.pymrpt.mrpt.system.WorkerThreadsPool, num_threads: int, p: mrpt::system::WorkerThreadsPool::queue_policy_t) -> None
clear(...)
clear(self: mrpt.pymrpt.mrpt.system.WorkerThreadsPool) -> None
 
C++: mrpt::system::WorkerThreadsPool::clear() --> void
pendingTasks(...)
pendingTasks(self: mrpt.pymrpt.mrpt.system.WorkerThreadsPool) -> int
 
Returns the number of enqueued tasks, currently waiting for a free
 working thread to process them.  
 
C++: mrpt::system::WorkerThreadsPool::pendingTasks() const --> std::size_t
resize(...)
resize(self: mrpt.pymrpt.mrpt.system.WorkerThreadsPool, num_threads: int) -> None
 
C++: mrpt::system::WorkerThreadsPool::resize(std::size_t) --> void

Data and other attributes defined here:
POLICY_DROP_OLD = <queue_policy_t.POLICY_DROP_OLD: 1>
POLICY_FIFO = <queue_policy_t.POLICY_FIFO: 0>
queue_policy_t = <class 'mrpt.pymrpt.mrpt.system.WorkerThreadsPool.queue_policy_t'>

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class mrptEvent(pybind11_builtins.pybind11_object)
    The basic event type for the observer-observable pattern in MRPT.
  You can sub-class this base class to create custom event types, then
   tell between them in runtime with isOfType<T>(), for example:
 
 
 
 
 
 
 
 
 
CObserverCObservable
 
 
Method resolution order:
mrptEvent
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.system.mrptEvent) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.system.mrptEvent, arg0: mrpt.pymrpt.mrpt.system.mrptEvent) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.system.mrptEvent, arg0: mrpt.pymrpt.mrpt.system.mrptEvent) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.system.mrptEvent, : mrpt.pymrpt.mrpt.system.mrptEvent) -> mrpt.pymrpt.mrpt.system.mrptEvent
 
C++: mrpt::system::mrptEvent::operator=(const class mrpt::system::mrptEvent &) --> class mrpt::system::mrptEvent &

Data descriptors defined here:
timestamp

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class mrptEventOnDestroy(mrptEvent)
    An event sent by any CObservable object (automatically) just before being
destroyed and telling its observers to unsubscribe.
 
 
Method resolution order:
mrptEventOnDestroy
mrptEvent
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.system.mrptEventOnDestroy, obj: mrpt::system::CObservable) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.system.mrptEventOnDestroy, : mrpt.pymrpt.mrpt.system.mrptEventOnDestroy) -> mrpt.pymrpt.mrpt.system.mrptEventOnDestroy
 
C++: mrpt::system::mrptEventOnDestroy::operator=(const class mrpt::system::mrptEventOnDestroy &) --> class mrpt::system::mrptEventOnDestroy &

Data descriptors inherited from mrptEvent:
timestamp

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
Functions
       
InvalidTimeStamp(...) method of builtins.PyCapsule instance
InvalidTimeStamp() -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Required to ensure INVALID_TIMESTAMP returns a "const T&"
  
 
 (New in MRPT 2.3.3)
 
C++: mrpt::system::InvalidTimeStamp() --> const mrpt::Clock::time_point &
MRPT_getCompilationDate(...) method of builtins.PyCapsule instance
MRPT_getCompilationDate() -> str
 
Returns the MRPT source code timestamp, according to the Reproducible-Builds
 specifications: https://reproducible-builds.org/specs/source-date-epoch/  
 
C++: mrpt::system::MRPT_getCompilationDate() --> std::string
MRPT_getVersion(...) method of builtins.PyCapsule instance
MRPT_getVersion() -> str
 
Returns a string describing the MRPT version 
 
C++: mrpt::system::MRPT_getVersion() --> std::string
buildTimestampFromParts(...) method of builtins.PyCapsule instance
buildTimestampFromParts(p: mrpt.pymrpt.mrpt.system.TTimeParts) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Builds a timestamp from the parts (Parts are in UTC)
 
 
 timestampToParts
 
C++: mrpt::system::buildTimestampFromParts(const struct mrpt::system::TTimeParts &) --> mrpt::Clock::time_point
buildTimestampFromPartsLocalTime(...) method of builtins.PyCapsule instance
buildTimestampFromPartsLocalTime(p: mrpt.pymrpt.mrpt.system.TTimeParts) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Builds a timestamp from the parts (Parts are in local time)
 
 
 timestampToParts, buildTimestampFromParts
 
C++: mrpt::system::buildTimestampFromPartsLocalTime(const struct mrpt::system::TTimeParts &) --> mrpt::Clock::time_point
changeCurrentProcessPriority(...) method of builtins.PyCapsule instance
changeCurrentProcessPriority(priority: mrpt.pymrpt.mrpt.system.TProcessPriority) -> None
 
Change the priority of the given process (it applies to all the threads,
  plus independent modifiers for each thread).
  - Windows: See
  [SetPriorityClass](https://msdn.microsoft.com/es-es/library/windows/desktop/ms686219(v=vs.85).aspx)
  - Linux (pthreads): Requires `root` permissions to increase process
  priority! Internally it calls [nice()](http://linux.die.net/man/3/nice), so it
  has no effect if
  () was called and a SCHED_RR is already active.
 
 
 createThread, changeThreadPriority
 
C++: mrpt::system::changeCurrentProcessPriority(enum mrpt::system::TProcessPriority) --> void
changeCurrentThreadPriority(...) method of builtins.PyCapsule instance
changeCurrentThreadPriority(priority: mrpt.pymrpt.mrpt.system.TThreadPriority) -> None
 
Change the priority of the current thread - for Windows, see also
 changeCurrentProcessPriority()
 - Windows: This is equivalent to
 [SetThreadPriority()](https://msdn.microsoft.com/en-us/library/windows/desktop/ms686277(v=vs.85).aspx)
 (read the docs there)
 - Linux (pthreads): May require `root` permissions! This sets the Round Robin
 scheduler with the given priority level. Read
 [sched_setscheduler](http://linux.die.net/man/2/sched_setscheduler). 
 
 
 createThread, changeCurrentProcessPriority, changeCurrentThreadPriority
 
C++: mrpt::system::changeCurrentThreadPriority(enum mrpt::system::TThreadPriority) --> void
clearConsole(...) method of builtins.PyCapsule instance
clearConsole() -> None
 
Clears the console window 
 
C++: mrpt::system::clearConsole() --> void
compute_CRC16(...) method of builtins.PyCapsule instance
compute_CRC16(*args, **kwargs)
Overloaded function.
 
1. compute_CRC16(data: int, len: int) -> int
 
2. compute_CRC16(data: int, len: int, gen_pol: int) -> int
 
C++: mrpt::system::compute_CRC16(const unsigned char *, size_t, const unsigned short) --> uint16_t
compute_CRC32(...) method of builtins.PyCapsule instance
compute_CRC32(*args, **kwargs)
Overloaded function.
 
1. compute_CRC32(data: int, len: int) -> int
 
2. compute_CRC32(data: int, len: int, gen_pol: int) -> int
 
C++: mrpt::system::compute_CRC32(const unsigned char *, size_t, const unsigned int) --> uint32_t
consoleColorAndStyle(...) method of builtins.PyCapsule instance
consoleColorAndStyle(*args, **kwargs)
Overloaded function.
 
1. consoleColorAndStyle(fg: mrpt.pymrpt.mrpt.system.ConsoleForegroundColor) -> None
 
2. consoleColorAndStyle(fg: mrpt.pymrpt.mrpt.system.ConsoleForegroundColor, bg: mrpt.pymrpt.mrpt.system.ConsoleBackgroundColor) -> None
 
3. consoleColorAndStyle(fg: mrpt.pymrpt.mrpt.system.ConsoleForegroundColor, bg: mrpt.pymrpt.mrpt.system.ConsoleBackgroundColor, style: mrpt.pymrpt.mrpt.system.ConsoleTextStyle) -> None
 
4. consoleColorAndStyle(fg: mrpt.pymrpt.mrpt.system.ConsoleForegroundColor, bg: mrpt.pymrpt.mrpt.system.ConsoleBackgroundColor, style: mrpt.pymrpt.mrpt.system.ConsoleTextStyle, applyToStdErr: bool) -> None
 
Changes the text color and style in the console for the text written from
 now on. See available colors in ConsoleForegroundColor and
 ConsoleBackgroundColor.
 
 By default the color of "cout" is changed, unless changeStdErr=true, in
 which case "cerr" is changed.
 
 
 GNU/Linux: If stdout/stderr is not a real terminal with color support,
 calling this function will have no effect (i.e. no escape characters will be
 emitted).
 
 
 The current implementation only supports a subset of all colors for
 Windows terminals.
 
 
 (New in MRPT 2.3.3)
 
C++: mrpt::system::consoleColorAndStyle(enum mrpt::system::ConsoleForegroundColor, enum mrpt::system::ConsoleBackgroundColor, enum mrpt::system::ConsoleTextStyle, bool) --> void
copyFile(...) method of builtins.PyCapsule instance
copyFile(*args, **kwargs)
Overloaded function.
 
1. copyFile(sourceFile: str, targetFile: str) -> bool
 
2. copyFile(sourceFile: str, targetFile: str, outErrStr: str) -> bool
 
Copies file  to  If the target file exists, it
 will be overwritten.
 
 
 true on success, false on any error, whose description can be
 optionally get in outErrStr
 
 
 (In MRPT 2.5.0, the copyAttributes param was removed)
 
C++: mrpt::system::copyFile(const std::string &, const std::string &, std::string *) --> bool
createDirectory(...) method of builtins.PyCapsule instance
createDirectory(dirName: str) -> bool
 
Creates a directory
 
 
 Returns false on any error, true on directory created or already
 existed.
 
C++: mrpt::system::createDirectory(const std::string &) --> bool
dateTimeLocalToString(...) method of builtins.PyCapsule instance
dateTimeLocalToString(t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t) -> str
 
Convert a timestamp into this textual form (in local time):
 YEAR/MONTH/DAY,HH:MM:SS.MMM
 
 
 dateTimeToString
 
C++: mrpt::system::dateTimeLocalToString(const mrpt::Clock::time_point) --> std::string
dateTimeToString(...) method of builtins.PyCapsule instance
dateTimeToString(t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t) -> str
 
Convert a timestamp into this textual form (UTC time):
 YEAR/MONTH/DAY,HH:MM:SS.MMM
 
 
 dateTimeLocalToString
 
C++: mrpt::system::dateTimeToString(const mrpt::Clock::time_point) --> std::string
dateToString(...) method of builtins.PyCapsule instance
dateToString(t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t) -> str
 
Convert a timestamp into this textual form: YEAR/MONTH/DAY
 
C++: mrpt::system::dateToString(const mrpt::Clock::time_point) --> std::string
deleteFile(...) method of builtins.PyCapsule instance
deleteFile(fileName: str) -> bool
 
Deletes a single file. For multiple files see deleteFiles
 
 
 Returns false on any error, true on everything OK.
 
 
 deleteFiles
 
C++: mrpt::system::deleteFile(const std::string &) --> bool
deleteFiles(...) method of builtins.PyCapsule instance
deleteFiles(s: str) -> None
 
Delete one or more files, especified by the (optional) path and the file
 name (including '?' or '*') - Use forward slash ('/') for directories for
 compatibility between Windows and Linux, since they will be internally
 traslated into backward slashes ('\') if MRPT is compiled under Windows.
 
 
 deleteFile
 
C++: mrpt::system::deleteFiles(const std::string &) --> void
deleteFilesInDirectory(...) method of builtins.PyCapsule instance
deleteFilesInDirectory(*args, **kwargs)
Overloaded function.
 
1. deleteFilesInDirectory(s: str) -> bool
 
2. deleteFilesInDirectory(s: str, deleteDirectoryAsWell: bool) -> bool
 
Delete all the files in a given directory (nothing done if directory does
 not exists, or path is a file).
 
 
 deleteFile
 
 
 true on success
 
C++: mrpt::system::deleteFilesInDirectory(const std::string &, bool) --> bool
directoryExists(...) method of builtins.PyCapsule instance
directoryExists(fileName: str) -> bool
 
Test if a given directory exists (it fails if the given path refers to an
 existing file).
 
 
 fileExists
 
C++: mrpt::system::directoryExists(const std::string &) --> bool
executeCommand(...) method of builtins.PyCapsule instance
executeCommand(*args, **kwargs)
Overloaded function.
 
1. executeCommand(command: str) -> int
 
2. executeCommand(command: str, output: str) -> int
 
3. executeCommand(command: str, output: str, mode: str) -> int
 
Execute Generic Shell Command
 
 
 Command to execute
 
 
  Pointer to string containing the shell output
 
 
 read/write access
 
 
 0 for success, -1 otherwise.
 
 
 Original code snippet found in http://stackoverflow.com/a/30357710
 
C++: mrpt::system::executeCommand(const std::string &, std::string *, const std::string &) --> int
extractDayTimeFromTimestamp(...) method of builtins.PyCapsule instance
extractDayTimeFromTimestamp(t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t) -> float
 
Returns the number of seconds ellapsed from midnight in the given timestamp
 
C++: mrpt::system::extractDayTimeFromTimestamp(const mrpt::Clock::time_point) --> double
extractFileDirectory(...) method of builtins.PyCapsule instance
extractFileDirectory(filePath: str) -> str
 
Extract the whole path (the directory) of a filename from a complete path
 plus name plus extension.
  This function works for either "/" or "\" directory separators.
 
 
 extractFileName,extractFileExtension
 
C++: mrpt::system::extractFileDirectory(const std::string &) --> std::string
extractFileExtension(...) method of builtins.PyCapsule instance
extractFileExtension(*args, **kwargs)
Overloaded function.
 
1. extractFileExtension(filePath: str) -> str
 
2. extractFileExtension(filePath: str, ignore_gz: bool) -> str
 
Extract the extension of a filename.
  For example, for "dummy.cpp", it will return "cpp".
  If "ignore_gz" is true, the second extension will be returned if the file
 name
   ends in ".gz", for example, for "foo.map.gz", this will return "map".
 
 
 extractFileName,extractFileDirectory
 
C++: mrpt::system::extractFileExtension(const std::string &, bool) --> std::string
extractFileName(...) method of builtins.PyCapsule instance
extractFileName(filePath: str) -> str
 
Extract just the name (without extension) of a filename from a complete path
 plus name plus extension.
  This function works for either "/" or "\" directory separators.
 
 
 extractFileExtension,extractFileDirectory
 
C++: mrpt::system::extractFileName(const std::string &) --> std::string
fileExists(...) method of builtins.PyCapsule instance
fileExists(fileName: str) -> bool
 
Test if a given file (or directory) exists.
 
 
 directoryExists
 
C++: mrpt::system::fileExists(const std::string &) --> bool
fileNameChangeExtension(...) method of builtins.PyCapsule instance
fileNameChangeExtension(filename: str, newExtension: str) -> str
 
Replace the filename extension by another one.
  Example:
   
 
 
 
 
 
C++: mrpt::system::fileNameChangeExtension(const std::string &, const std::string &) --> std::string
fileNameStripInvalidChars(...) method of builtins.PyCapsule instance
fileNameStripInvalidChars(*args, **kwargs)
Overloaded function.
 
1. fileNameStripInvalidChars(filename: str) -> str
 
2. fileNameStripInvalidChars(filename: str, replacement_to_invalid_chars: str) -> str
 
Replace invalid filename chars by underscores ('_') or any other user-given
 char.
  Invalid chars are: '<','>',':','"','/','\','|','?','*'
 
C++: mrpt::system::fileNameStripInvalidChars(const std::string &, const char) --> std::string
filePathSeparatorsToNative(...) method of builtins.PyCapsule instance
filePathSeparatorsToNative(filePath: str) -> str
 
Windows: replace all '/'->'\' , in Linux/MacOS: replace all '\'->'/' 
 
C++: mrpt::system::filePathSeparatorsToNative(const std::string &) --> std::string
find_mrpt_shared_dir(...) method of builtins.PyCapsule instance
find_mrpt_shared_dir() -> str
 
Finds the "[MRPT]/share/mrpt/" directory, if available in the system. This
 searches in (1) source code tree, (2) install target paths. 
 
C++: mrpt::system::find_mrpt_shared_dir() --> std::string
firstNLines(...) method of builtins.PyCapsule instance
firstNLines(str: str, n: int) -> str
 
Returns the first `n` lines (splitted by '' chars) of the given text.
 
 
 New in MRPT 2.3.2
 
C++: mrpt::system::firstNLines(const std::string &, size_t) --> std::string
formatTimeInterval(...) method of builtins.PyCapsule instance
formatTimeInterval(timeSeconds: float) -> str
 
Returns a formated string with the given time difference (passed as the
 number of seconds), as a string [H]H:MM:SS.MILLISECONDS
 
 
 unitsFormat
 
C++: mrpt::system::formatTimeInterval(const double) --> std::string
getCurrentTime(...) method of builtins.PyCapsule instance
getCurrentTime() -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns the current (UTC) system time.
 
 
 now
 
C++: mrpt::system::getCurrentTime() --> mrpt::Clock::time_point
getFileModificationTime(...) method of builtins.PyCapsule instance
getFileModificationTime(filename: str) -> int
 
Return the time of the file last modification, or "0" if the file doesn't
 exist.  
 
C++: mrpt::system::getFileModificationTime(const std::string &) --> long
getFileSize(...) method of builtins.PyCapsule instance
getFileSize(fileName: str) -> int
 
Return the size of the given file, or size_t(-1) if some error is found
 accessing that file.  
 
C++: mrpt::system::getFileSize(const std::string &) --> uint64_t
getMRPTLicense(...) method of builtins.PyCapsule instance
getMRPTLicense() -> str
 
Returns a const ref to a text with the same text that appears at the
 beginning of each MRPT file (useful for displaying the License text in GUIs)
 
C++: mrpt::system::getMRPTLicense() --> const std::string &
getMemoryUsage(...) method of builtins.PyCapsule instance
getMemoryUsage() -> int
 
Returns the memory occupied by this process, in bytes 
 
C++: mrpt::system::getMemoryUsage() --> unsigned long
getShareMRPTDir(...) method of builtins.PyCapsule instance
getShareMRPTDir() -> str
 
Attempts to find the directory `[PREFIX/]share/mrpt/` and returns its
 absolute path, or empty string if not found.
 Example return paths: Linux after installing = `/usr/share/mrpt/`;
 manually-built system = `[MRPT_SOURCE_DIR]/share/mrpt/`, etc.  
 
C++: mrpt::system::getShareMRPTDir() --> std::string
getTempFileName(...) method of builtins.PyCapsule instance
getTempFileName() -> str
 
Returns the name of a proposed temporary file name 
 
C++: mrpt::system::getTempFileName() --> std::string
getcwd(...) method of builtins.PyCapsule instance
getcwd() -> str
 
Returns the current working directory  
 
C++: mrpt::system::getcwd() --> std::string
global_profiler_enter(...) method of builtins.PyCapsule instance
global_profiler_enter(func_name: str) -> None
 
macros.
  @{ 
 
C++: mrpt::system::global_profiler_enter(const char *) --> void
global_profiler_getref(...) method of builtins.PyCapsule instance
global_profiler_getref() -> mrpt.pymrpt.mrpt.system.CTimeLogger
 
C++: mrpt::system::global_profiler_getref() --> class mrpt::system::CTimeLogger &
global_profiler_leave(...) method of builtins.PyCapsule instance
global_profiler_leave(func_name: str) -> None
 
C++: mrpt::system::global_profiler_leave(const char *) --> void
intervalFormat(...) method of builtins.PyCapsule instance
intervalFormat(seconds: float) -> str
 
This function implements time interval formatting: Given a time in seconds,
 it will return a string describing the interval with the most appropriate
 unit.
 E.g.:
  - "1 year, 3 days, 4 minutes"
  - "3 days, 8 hours"
  - "9 hours, 4 minutes, 4.3 sec",
  - "3.34 sec"
  - "178.1 ms"
  - "87.1 us"
 
 
 unitsFormat
 
C++: mrpt::system::intervalFormat(const double) --> std::string
launchProcess(...) method of builtins.PyCapsule instance
launchProcess(command: str) -> bool
 
Executes the given command (which may contain a program + arguments), and
waits until it finishes.
 
 
 false on any error, true otherwise
 
C++: mrpt::system::launchProcess(const std::string &) --> bool
lowerCase(...) method of builtins.PyCapsule instance
lowerCase(str: str) -> str
 
Returns an lower-case version of a string.
 
 
 upperCase  
 
C++: mrpt::system::lowerCase(const std::string &) --> std::string
md5(...) method of builtins.PyCapsule instance
md5(*args, **kwargs)
Overloaded function.
 
1. md5(str: str) -> str
 
Header: `#include <mrpt/system/md5.h>`.
 Library: 
  
 
 
 @{ 
 
 Computes the md5 of a block of data. 
 
C++: mrpt::system::md5(const std::string &) --> std::string
 
2. md5(data: int, len: int) -> str
 
Computes the md5 of a block of data. 
 
C++: mrpt::system::md5(const unsigned char *, size_t) --> std::string
now(...) method of builtins.PyCapsule instance
now() -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
A shortcut for system::getCurrentTime
 
 
 getCurrentTime
 
C++: mrpt::system::now() --> mrpt::Clock::time_point
now_double(...) method of builtins.PyCapsule instance
now_double() -> float
 
Returns the current time, as a `double` (fractional version of time_t)
 instead of a `TTimeStamp`.
 
 
 now(), timestampTotime_t() 
 
C++: mrpt::system::now_double() --> double
nthOccurrence(...) method of builtins.PyCapsule instance
nthOccurrence(str: str, strToFind: str, nth: int) -> int
 
Finds the position of the n-th occurence of the given substring, or
 std::string::npos if it does not happen.
 
 
 New in MRPT 2.3.2
 
C++: mrpt::system::nthOccurrence(const std::string &, const std::string &, size_t) --> size_t
pathJoin(...) method of builtins.PyCapsule instance
pathJoin(paths: List[str]) -> str
 
Portable version of std::filesystem::path::append(), with Python-like name.
 
  
 
 
 
 
  
 (New in MRPT 2.5.0)
 
C++: mrpt::system::pathJoin(const class std::vector<std::string > &) --> std::string
pause(...) method of builtins.PyCapsule instance
pause(*args, **kwargs)
Overloaded function.
 
1. pause() -> None
 
2. pause(msg: str) -> None
 
Shows the message "Press any key to continue" (or other custom message) to
 the current standard output and returns when a key is pressed 
 
C++: mrpt::system::pause(const std::string &) --> void
progress(...) method of builtins.PyCapsule instance
progress(*args, **kwargs)
Overloaded function.
 
1. progress(progressRatio0to1: float, barLength: int) -> str
 
2. progress(progressRatio0to1: float, barLength: int, encloseInSquareBrackets: bool) -> str
 
Build an text incremental progress bar with
 [UNICODE block elements](https://en.wikipedia.org/wiki/Block_Elements),
 for example:
 
 
 
 
 See example: 
 
 
 
 
 
 
 (New in MRPT 2.3.0)
 
C++: mrpt::system::progress(const double, const unsigned long, bool) --> std::string
renameFile(...) method of builtins.PyCapsule instance
renameFile(*args, **kwargs)
Overloaded function.
 
1. renameFile(oldFileName: str, newFileName: str) -> bool
 
2. renameFile(oldFileName: str, newFileName: str, error_msg: str) -> bool
 
Renames a file - If the target path is different and the filesystem allows
 it, it will be moved to the new location.
 
 
 false on any error. In that case, if a pointer to a receiver string
 is passed in error_msg, a description of the error is saved there.
 
C++: mrpt::system::renameFile(const std::string &, const std::string &, std::string *) --> bool
rightPad(...) method of builtins.PyCapsule instance
rightPad(*args, **kwargs)
Overloaded function.
 
1. rightPad(str: str, total_len: int) -> str
 
2. rightPad(str: str, total_len: int, truncate_if_larger: bool) -> str
 
Enlarge the string with spaces up to the given length. 
 
C++: mrpt::system::rightPad(const std::string &, size_t, bool) --> std::string
strCmp(...) method of builtins.PyCapsule instance
strCmp(s1: str, s2: str) -> bool
 
Return true if the two strings are equal (case sensitive)  
 strCmpI  
 
C++: mrpt::system::strCmp(const std::string &, const std::string &) --> bool
strCmpI(...) method of builtins.PyCapsule instance
strCmpI(s1: str, s2: str) -> bool
 
Return true if the two strings are equal (case insensitive)  
 strCmp 
 
C++: mrpt::system::strCmpI(const std::string &, const std::string &) --> bool
strStarts(...) method of builtins.PyCapsule instance
strStarts(str: str, subStr: str) -> bool
 
Return true if "str" starts with "subStr" (case sensitive)  
 strStartsI
 
C++: mrpt::system::strStarts(const std::string &, const std::string &) --> bool
strStartsI(...) method of builtins.PyCapsule instance
strStartsI(str: str, subStr: str) -> bool
 
Return true if "str" starts with "subStr" (case insensitive)  
 strStarts
 
C++: mrpt::system::strStartsI(const std::string &, const std::string &) --> bool
stringListAsString(...) method of builtins.PyCapsule instance
stringListAsString(*args, **kwargs)
Overloaded function.
 
1. stringListAsString(lst: List[str], out: str) -> None
 
2. stringListAsString(lst: List[str], out: str, newline: str) -> None
 
Convert a string list to one single string with new-lines. 
 
C++: mrpt::system::stringListAsString(const class std::vector<std::string > &, std::string &, const std::string &) --> void
thread_name(...) method of builtins.PyCapsule instance
thread_name(*args, **kwargs)
Overloaded function.
 
1. thread_name(name: str) -> None
 
Sets the name of the current thread; useful for debuggers.
 
 
 
 
 New in MRPT 2.0.4
 
C++: mrpt::system::thread_name(const std::string &) --> void
 
2. thread_name() -> str
 
Gets the name of the current thread; useful for debuggers.
 
 
 
 
 New in MRPT 2.0.4
 
C++: mrpt::system::thread_name() --> std::string
timeDifference(...) method of builtins.PyCapsule instance
timeDifference(t_first: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, t_later: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t) -> float
 
Returns the time difference from t1 to t2 (positive if t2 is posterior to
 t1), in seconds  
 
C++: mrpt::system::timeDifference(const mrpt::Clock::time_point &, const mrpt::Clock::time_point &) --> double
timeLocalToString(...) method of builtins.PyCapsule instance
timeLocalToString(*args, **kwargs)
Overloaded function.
 
1. timeLocalToString(t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t) -> str
 
2. timeLocalToString(t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, secondFractionDigits: int) -> str
 
Convert a timestamp into this textual form (in local time): HH:MM:SS.MMMMMM
 
C++: mrpt::system::timeLocalToString(const mrpt::Clock::time_point, unsigned int) --> std::string
timeToString(...) method of builtins.PyCapsule instance
timeToString(t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t) -> str
 
Convert a timestamp into this textual form (UTC): HH:MM:SS.MMMMMM
 
C++: mrpt::system::timeToString(const mrpt::Clock::time_point) --> std::string
time_tToTimestamp(...) method of builtins.PyCapsule instance
time_tToTimestamp(*args, **kwargs)
Overloaded function.
 
1. time_tToTimestamp(t: float) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Transform from standard "time_t" (actually a double number, it can contain
 fractions of seconds) to TTimeStamp.
 
 
 timestampTotime_t
 
C++: mrpt::system::time_tToTimestamp(const double) --> mrpt::Clock::time_point
 
2. time_tToTimestamp(t: int) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Transform from standard "time_t" to TTimeStamp.
 
 
 timestampTotime_t
 
C++: mrpt::system::time_tToTimestamp(const long &) --> mrpt::Clock::time_point
timestampAdd(...) method of builtins.PyCapsule instance
timestampAdd(tim: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, num_seconds: float) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Shifts a timestamp the given amount of seconds (>0: forwards in time, <0:
 backwards)  
 
C++: mrpt::system::timestampAdd(const mrpt::Clock::time_point, const double) --> mrpt::Clock::time_point
timestampToDouble(...) method of builtins.PyCapsule instance
timestampToDouble(t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t) -> float
 
Transform from TTimeStamp to standard "time_t" (actually a double number, it
 can contain fractions of seconds).
 This function is just an (inline) alias of timestampTotime_t(), with a more
 significant name.
 
 
 time_tToTimestamp
 
C++: mrpt::system::timestampToDouble(const mrpt::Clock::time_point) --> double
timestampToParts(...) method of builtins.PyCapsule instance
timestampToParts(*args, **kwargs)
Overloaded function.
 
1. timestampToParts(t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, p: mrpt.pymrpt.mrpt.system.TTimeParts) -> None
 
2. timestampToParts(t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, p: mrpt.pymrpt.mrpt.system.TTimeParts, localTime: bool) -> None
 
Gets the individual parts of a date/time (days, hours, minutes, seconds) -
 UTC time or local time
 
 
 buildTimestampFromParts
 
C++: mrpt::system::timestampToParts(mrpt::Clock::time_point, struct mrpt::system::TTimeParts &, bool) --> void
timestampTotime_t(...) method of builtins.PyCapsule instance
timestampTotime_t(t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t) -> float
 
Transform from TTimeStamp to standard "time_t" (actually a double number, it
 can contain fractions of seconds).
 
 
 time_tToTimestamp
 
C++: mrpt::system::timestampTotime_t(const mrpt::Clock::time_point) --> double
toAbsolutePath(...) method of builtins.PyCapsule instance
toAbsolutePath(*args, **kwargs)
Overloaded function.
 
1. toAbsolutePath(path: str) -> str
 
2. toAbsolutePath(path: str, resolveToCanonical: bool) -> str
 
Portable version of std::filesystem::absolute() and canonical()
 
 If `canonical==true` relative paths, symlinks, etc. will be resolved too,
 but an exception will be thrown if the referenced file/path does not exist.
 If `canonical==true`, an absolute path will be always returned, even if does
 not actually exist.
 
  
 
 
 
  
 (New in MRPT 2.5.0)
 
C++: mrpt::system::toAbsolutePath(const std::string &, bool) --> std::string
tokenize(...) method of builtins.PyCapsule instance
tokenize(*args, **kwargs)
Overloaded function.
 
1. tokenize(inString: str, inDelimiters: str, outTokens: List[str]) -> None
 
2. tokenize(inString: str, inDelimiters: str, outTokens: List[str], skipBlankTokens: bool) -> None
 
Tokenizes a string according to a set of delimiting characters.
 Example:
 
 
 
 
 
  Will generate 3 tokens:
                - "Pepe"
                - "Er"
                - "Muo"
 
 
 If `true`, consecutive "delimiters" will be
 considered one single delimiters. If `false`, a blank token will be returned
 between each pair of delimiters.
 
 
 Can be a std::vector or std::deque of std::string's.
 
C++: mrpt::system::tokenize(const std::string &, const std::string &, class std::vector<std::string > &, bool) --> void
trim(...) method of builtins.PyCapsule instance
trim(str: str) -> str
 
Removes leading and trailing spaces 
 
C++: mrpt::system::trim(const std::string &) --> std::string
unitsFormat(...) method of builtins.PyCapsule instance
unitsFormat(*args, **kwargs)
Overloaded function.
 
1. unitsFormat(val: float) -> str
 
2. unitsFormat(val: float, nDecimalDigits: int) -> str
 
3. unitsFormat(val: float, nDecimalDigits: int, middle_space: bool) -> str
 
This function implements formatting with the appropriate SI metric unit
 prefix: 1e-12->'p', 1e-9->'n', 1e-6->'u', 1e-3->'m', 1->'', 1e3->'K',
 1e6->'M', 1e9->'G', 1e12->'T' 
 
 intervalFormat 
 
C++: mrpt::system::unitsFormat(const double, int, bool) --> std::string
upperCase(...) method of builtins.PyCapsule instance
upperCase(str: str) -> str
 
Returns a upper-case version of a string.
 
 
 lowerCase  
 
C++: mrpt::system::upperCase(const std::string &) --> std::string

 
Data
        LVL_DEBUG = <VerbosityLevel.LVL_DEBUG: 0>
LVL_ERROR = <VerbosityLevel.LVL_ERROR: 3>
LVL_INFO = <VerbosityLevel.LVL_INFO: 1>
LVL_WARN = <VerbosityLevel.LVL_WARN: 2>
NUMBER_OF_VERBOSITY_LEVELS = <VerbosityLevel.NUMBER_OF_VERBOSITY_LEVELS: 4>
ppHigh = <TProcessPriority.ppHigh: 2>
ppIdle = <TProcessPriority.ppIdle: 0>
ppNormal = <TProcessPriority.ppNormal: 1>
ppVeryHigh = <TProcessPriority.ppVeryHigh: 3>
tpHigh = <TThreadPriority.tpHigh: 1>
tpHigher = <TThreadPriority.tpHigher: 2>
tpHighest = <TThreadPriority.tpHighest: 15>
tpLow = <TThreadPriority.tpLow: -1>
tpLower = <TThreadPriority.tpLower: -2>
tpLowests = <TThreadPriority.tpLowests: -15>
tpNormal = <TThreadPriority.tpNormal: 0>