Cargo.toml

@@ -1,11 +1,17 @@
 [workspace]
 resolver = "2"
-members = [".", "members/libpt-core", "members/libpt-log", "members/libpt-cli"]
+members = [
+  ".",
+  "members/libpt-core",
+  "members/libpt-log",
+  "members/libpt-py",
+  "members/libpt-cli",
+]
 default-members = [".", "members/libpt-core"]
 
 [workspace.package]
 publish = true
-version = "0.7.3-alpha.2"
+version = "0.6.0-alpha.0"
 edition = "2021"
 authors = ["Christoph J. Scherr <software@cscherr.de>"]
 license = "GPL-3.0-or-later"
@@ -14,15 +20,19 @@ readme = "README.md"
 homepage = "https://git.cscherr.de/PlexSheep/pt"
 repository = "https://git.cscherr.de/PlexSheep/pt"
 keywords = ["library"]
-categories = ["command-line-utilities", "development-tools"]
+categories = [
+  "command-line-utilities",
+  "development-tools",
+  "development-tools::ffi",
+]
 
 [workspace.dependencies]
 anyhow = "1.0.79"
 thiserror = "1.0.56"
-libpt-core = { version = "0.5.0", path = "members/libpt-core" }
+libpt-core = { version = "0.4.0", path = "members/libpt-core" }
 libpt-bintols = { version = "0.5.1", path = "members/libpt-bintols" }
-libpt-log = { version = "0.6.2-alpha.1", path = "members/libpt-log" }
-libpt-cli = { version = "0.2.2-alpha.1", path = "members/libpt-cli" }
+libpt-log = { version = "0.4.2", path = "members/libpt-log" }
+libpt-cli = { version = "0.1.0", path = "members/libpt-cli" }
 
 [package]
 name = "libpt"
@@ -41,11 +51,11 @@ categories.workspace = true
 [features]
 default = ["log", "core"]
 core = []
-full = ["default", "core", "log", "bintols", "libpt-cli/full"]
+full = ["default", "core", "log", "bintols"]
 log = ["dep:libpt-log"]
-log-crate = ["libpt-cli/log"]
 bintols = ["dep:libpt-bintols", "log"]
 cli = ["dep:libpt-cli", "core", "log"]
+# py = ["dep:libpt-py"]
 
 [lib]
 name = "libpt"
@@ -59,8 +69,4 @@ crate-type = [
 libpt-core = { workspace = true }
 libpt-bintols = { workspace = true, optional = true }
 libpt-log = { workspace = true, optional = true }
-libpt-cli = { workspace = true, optional = true, features = ["log"] }
-
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = ["--cfg", "docsrs"]
+libpt-cli = { workspace = true, optional = true }

README.md

@@ -40,19 +40,12 @@ If you want to use the python variant too, you need to compile with maturing.
 
 ## Installing from [pypi](https://pypi.org)
 
-The Python interface of `libpt` is currently not implemented, but it is planned
-to eventually re add it. Meanwhile, you can use a much older version if you
-really want.
+`libpt` has been packaged for [pypi.org](https://pypi.org/project/libpt/).
 
-> :warning: **This will install a very old version**
->
-> `libpt` has been packaged for [pypi.org](https://pypi.org/project/libpt/).
->
-> You can install it with `pip install libpt`
+You can install it with `pip install libpt`
 
 ## Installing from [crates.io](https://crates.io)
 
-
 `libpt` has been packaged for [crates.io](https://crates.io/crates/libpt).
 
 You can add the library to your project with `cargo add libpt`.

members/libpt-bintols/Cargo.toml

@@ -20,7 +20,3 @@ libpt-core = { workspace = true }
 libpt-log = { workspace = true }
 anyhow = { workspace = true }
 thiserror = { workspace = true }
-
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = ["--cfg", "docsrs"]

members/libpt-cli/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "libpt-cli"
 publish.workspace = true
-version = "0.2.2-alpha.2"
+version = "0.1.0"
 edition.workspace = true
 authors.workspace = true
 license.workspace = true
@@ -12,9 +12,11 @@ repository.workspace = true
 keywords.workspace = true
 categories.workspace = true
 
+[package.metadata.docs.rs]
+cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
+
 [features]
 default = []
-full = ["log"]
 log = ["dep:log"]
 
 [dependencies]
@@ -24,14 +26,11 @@ comfy-table = "7.1.1"
 console = "0.15.8"
 dialoguer = { version = "0.11.0", features = ["completion", "history"] }
 embed-doc-image = "0.1.4"
+exitcode = "1.1.2"
+human-panic = "2.0.0"
 indicatif = "0.17.8"
 libpt-log = { workspace = true, optional = false }
 log = { version = "0.4.21", optional = true }
-serde = { version = "1.0.209", features = ["derive"] }
 shlex = "1.3.0"
 strum = { version = "0.26.3", features = ["derive"] }
 thiserror.workspace = true
-
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = ["--cfg", "docsrs"]

members/libpt-cli/examples/cli.rs

@@ -1,6 +1,6 @@
 use clap::Parser;
 use libpt_cli::args::VerbosityLevel;
-use libpt_cli::printing;
+use libpt_cli::{clap, printing};
 use libpt_log::{debug, Logger};
 
 /// This is the help
@@ -23,7 +23,10 @@ struct Cli {
 
 fn main() {
     let cli = Cli::parse();
-    let _logger = Logger::builder().set_level(cli.verbosity.level()).build();
+    let _logger = Logger::builder()
+        .max_level(cli.verbosity.level())
+        .show_time(false)
+        .build();
 
     debug!("logger initialized with level: {}", cli.verbosity.level());
 

members/libpt-cli/examples/repl.rs

@@ -1,7 +1,7 @@
 use console::style;
-use libpt_cli::printing;
 use libpt_cli::repl::{DefaultRepl, Repl};
-use libpt_log::{debug, Logger};
+use libpt_cli::{clap, printing, strum};
+use libpt_log::{debug, Level, Logger};
 
 use clap::Subcommand;
 use strum::EnumIter;
@@ -31,7 +31,10 @@ enum ReplCommand {
 fn main() -> anyhow::Result<()> {
     // You would normally make a proper cli interface with clap before entering the repl. This is
     // omitted here for brevity
-    let _logger = Logger::builder().display_time(false).build();
+    let _logger = Logger::builder()
+        .show_time(false)
+        .max_level(Level::INFO)
+        .build()?;
 
     // the compiler can infer that we want to use the ReplCommand enum.
     let mut repl = DefaultRepl::<ReplCommand>::default();
@@ -73,7 +76,7 @@ fn main() -> anyhow::Result<()> {
                 if !fancy {
                     println!("{}", text.join(" "))
                 } else {
-                    printing::blockprint(text.join(" "), console::Color::Cyan)
+                    printing::blockprint(&text.join(" "), console::Color::Cyan)
                 }
             }
         }

members/libpt-cli/src/args.rs

@@ -4,7 +4,6 @@ use clap::Parser;
 use libpt_log::Level;
 #[cfg(feature = "log")]
 use log;
-use serde::{Deserialize, Serialize};
 
 /// Custom help template for displaying command-line usage information
 ///
@@ -19,7 +18,7 @@ use serde::{Deserialize, Serialize};
 /// # use libpt_cli::args::HELP_TEMPLATE;
 /// use clap::Parser;
 /// #[derive(Parser, Debug, Clone, PartialEq, Eq, Hash)]
-/// #[command(help_template = HELP_TEMPLATE, author, version)]
+/// #[command(help_template = HELP_TEMPLATE)]
 /// pub struct MyArgs {
 ///     /// show more details
 ///     #[arg(short, long)]
@@ -78,9 +77,9 @@ Author: {author-with-newline}
 /// Get the loglevel like this:
 ///
 /// ```no_run
-/// use libpt_cli::args::VerbosityLevel;
+/// # use libpt_cli::args::VerbosityLevel;
 /// use libpt_log::Level;
-/// use clap::Parser;
+/// # use clap::Parser;
 ///
 /// # #[derive(Parser, Debug)]
 /// # pub struct Opts {
@@ -96,18 +95,18 @@ Author: {author-with-newline}
 ///     let level: Level = opts.verbose.level();
 /// }
 /// ```
-#[derive(Parser, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
+#[derive(Parser, Clone, PartialEq, Eq, Hash)]
 pub struct VerbosityLevel {
     /// make the output more verbose
     #[arg(
         long,
         short = 'v',
-        action = clap::ArgAction::Count, // NOTE: this forces u8 type for some reason
+        action = clap::ArgAction::Count,
         global = true,
         // help = L::verbose_help(),
         // long_help = L::verbose_long_help(),
     )]
-    verbose: u8,
+    verbose: i8,
 
     /// make the output less verbose
     ///
@@ -119,7 +118,7 @@ pub struct VerbosityLevel {
         global = true,
         conflicts_with = "verbose",
     )]
-    quiet: u8,
+    quiet: i8,
 }
 
 impl VerbosityLevel {
@@ -132,7 +131,7 @@ impl VerbosityLevel {
     }
     #[inline]
     #[must_use]
-    fn value(&self) -> u8 {
+    fn value(&self) -> i8 {
         Self::level_value(Level::INFO)
             .saturating_sub((self.quiet).min(10))
             .saturating_add((self.verbose).min(10))
@@ -190,7 +189,7 @@ impl VerbosityLevel {
 
     #[inline]
     #[must_use]
-    const fn level_value(level: Level) -> u8 {
+    const fn level_value(level: Level) -> i8 {
         match level {
             Level::TRACE => 4,
             Level::DEBUG => 3,

members/libpt-cli/src/lib.rs

@@ -1,6 +1,14 @@
-//! This module bundles a lot of good CLI tools, and adds some of it's own, to make development of
-//! CLI apps easier and more ergonomic.
 #![warn(clippy::pedantic, clippy::style, clippy::nursery)]
 pub mod args;
 pub mod printing;
 pub mod repl;
+
+pub use clap;
+pub use comfy_table;
+pub use console;
+pub use dialoguer;
+pub use exitcode;
+pub use human_panic;
+pub use indicatif;
+pub use shlex;
+pub use strum;

members/libpt-cli/src/printing.rs

@@ -42,7 +42,7 @@ use console::{style, Color};
 /// # Example
 ///
 /// ```
-/// use console::Color;
+/// use libpt_cli::console::Color;
 /// use libpt_cli::printing::blockprint;
 /// # fn main() {
 /// blockprint("Hello world!", Color::Blue);
@@ -64,7 +64,7 @@ pub fn blockprint(content: impl ToString, color: Color) {
 /// # Example
 ///
 /// ```
-/// use console::Color;
+/// use libpt_cli::console::Color;
 /// use libpt_cli::printing::blockfmt;
 /// # fn main() {
 /// let formatted_content = blockfmt("Hello world!", Color::Blue);
@@ -93,8 +93,8 @@ pub fn blockfmt(content: impl ToString, color: Color) -> String {
 ///
 /// # Example
 /// ```
-/// use comfy_table::{presets, CellAlignment, ContentArrangement};
-/// use console::Color;
+/// use libpt_cli::comfy_table::{presets, CellAlignment, ContentArrangement};
+/// use libpt_cli::console::Color;
 /// use libpt_cli::printing::blockfmt_advanced;
 /// # fn main() {
 /// println!(

members/libpt-cli/src/repl/default.rs

@@ -27,8 +27,8 @@ use libpt_log::trace;
 ///
 /// ```no_run
 /// use libpt_cli::repl::{DefaultRepl, Repl};
-/// use clap::Subcommand;
-/// use strum::EnumIter;
+/// use libpt_cli::clap::Subcommand;
+/// use libpt_cli::strum::EnumIter;
 ///
 /// #[derive(Subcommand, Debug, EnumIter, Clone)]
 /// enum ReplCommand {

members/libpt-core/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "libpt-core"
 publish.workspace = true
-version = "0.5.0"
+version = "0.4.0"
 edition.workspace = true
 authors.workspace = true
 license.workspace = true
@@ -14,9 +14,6 @@ categories.workspace = true
 
 [dependencies]
 anyhow = "1.0.79"
+libpt-log = { workspace = true }
 
 [dev-dependencies]
-
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = ["--cfg", "docsrs"]

members/libpt-core/src/lib.rs

@@ -8,16 +8,3 @@
 
 /// macros to make things faster in your code
 pub mod macros;
-
-/// ## Get the name of the crate that uses your library
-///
-/// Let's say you're writing the library `foo` and need the name of the crate that uses `foo`. With
-/// this function, you can get the name of the crate that uses `foo`.
-///
-/// Will return [None] if [`std::env::current_exe()`] errors or if conversion to [String] from [std::ffi::OsStr] fails.
-pub fn get_crate_name() -> Option<String> {
-    if let Ok(exe) = std::env::current_exe() {
-        return Some(exe.file_stem()?.to_str()?.to_string());
-    }
-    None
-}

members/libpt-log/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "libpt-log"
 publish.workspace = true
-version = "0.6.2-alpha.2"
+version = "0.4.3"
 edition.workspace = true
 authors.workspace = true
 license.workspace = true
@@ -13,17 +13,11 @@ keywords.workspace = true
 categories.workspace = true
 
 [dependencies]
-tracing = "0.1.40"
-tracing-appender = "0.2.3"
-tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
+tracing = "0.1.37"
+tracing-appender = "0.2.2"
+tracing-subscriber = "0.3.17"
 anyhow = { workspace = true }
 thiserror = { workspace = true }
-libpt-core = { workspace = true, optional = false }
-chrono = "0.4.38"
 
 [dev-dependencies]
 gag = "1.0.0"
-
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = ["--cfg", "docsrs"]

members/libpt-log/examples/logfile.rs

@@ -1,11 +0,0 @@
-use libpt_log::Logger;
-use tracing::info;
-
-fn main() {
-    let _logger = Logger::builder()
-        .log_to_file(true)
-        .log_dir("/tmp/llll".into())
-        .build()
-        .unwrap();
-    info!("foo bar qux");
-}

members/libpt-log/src/error.rs

@@ -17,9 +17,7 @@ pub enum Error {
     /// Could not assign logger as the global default
     #[error("Could not assign logger as global default")]
     SetGlobalDefaultFail(#[from] SetGlobalDefaultError),
-    /// any other error type, wrapped in [`anyhow::Error`]
+    /// any other error type, wrapped in [anyhow::Error](anyhow::Error)
     #[error(transparent)]
     Other(#[from] anyhow::Error),
-    #[error("Tried to open the logfile, but logging to file was not requested")]
-    LogfileButNoFilelog,
 }

members/libpt-log/src/lib.rs

@@ -6,34 +6,27 @@
 //! For the library version, only the basic [`tracing`] is used, so that it is possible for
 //! the end user to use the [`tracing`] frontend they desire.
 //!
-//! I did decide to create a [`Logger`] struct. This struct is mainly intended to be used with the
-//! python module of [`pt`](../libpt/index.html), but is still just as usable in other contexts.
-//! You can use this struct when use of the macros is not possible, but the macros should generally
-//! be preferred.
+//! I did however decide to create a [`Logger`] struct. This struct is mainly intended to be used
+//! with the python module of [`pt`](../libpt/index.html), but is still just as usable in other contexts.
 //!
 //! ## Technologies used for logging:
 //! - [`tracing`]: base logging crate
 //! - [`tracing_appender`]: Used to log to files
 //! - [`tracing_subscriber`]: Used to do actual logging, formatting, to stdout
-#![warn(clippy::pedantic, clippy::style, clippy::nursery)]
 
 use std::{
-    fmt::{self, Debug},
+    fmt,
     path::PathBuf,
     sync::atomic::{AtomicBool, Ordering},
 };
 
 pub mod error;
-use error::Error;
+use error::*;
 
-/// This is the magic dependency where the cool stuff happens
-///
-/// I'm just repackaging it a little to make it more ergonomic
 pub use tracing;
 pub use tracing::{debug, error, info, trace, warn, Level};
-use tracing_subscriber::{
-    fmt::format::FmtSpan, layer::SubscriberExt as _, util::SubscriberInitExt, Layer,
-};
+use tracing_appender::{self, non_blocking::NonBlocking};
+use tracing_subscriber::fmt::{format::FmtSpan, time};
 
 use anyhow::{bail, Result};
 /// The log level used when none is specified
@@ -62,9 +55,7 @@ static INITIALIZED: AtomicBool = AtomicBool::new(false);
 /// # }
 ///
 /// ```
-#[derive(PartialEq, Eq, PartialOrd, Ord, Debug)]
-#[allow(clippy::struct_excessive_bools)] // it's just true/false values, not states, and I don't
-                                         // need to reinvent the wheel
+#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
 pub struct LoggerBuilder {
     /// create and log to logfiles
     log_to_file: bool,
@@ -95,8 +86,6 @@ pub struct LoggerBuilder {
     show_time: bool,
     /// show timestamps as uptime (duration since the logger was initialized)
     uptime: bool,
-    /// log when span things happen
-    span_events: FmtSpan,
 }
 
 impl LoggerBuilder {
@@ -131,89 +120,110 @@ impl LoggerBuilder {
     /// This function will return an error if a global Logger was aready initialized. This module
     /// uses the [tracing] crate for logging, so if a [tracing] logger is initialized elsewhere,
     /// this method will error.
-    #[allow(clippy::missing_panics_doc)]
     pub fn build(self) -> Result<Logger> {
         // only init if no init has been performed yet
         if INITIALIZED.load(Ordering::Relaxed) {
             warn!("trying to reinitialize the logger, ignoring");
             bail!(Error::Usage("logging is already initialized".to_string()));
         }
-        let layer = tracing_subscriber::fmt::layer()
+        let subscriber = tracing_subscriber::fmt::Subscriber::builder()
+            .with_level(self.display_level)
+            .with_max_level(self.max_level)
             .with_ansi(self.ansi)
             .with_target(self.display_target)
             .with_file(self.display_filename)
             .with_thread_ids(self.display_thread_ids)
             .with_line_number(self.display_line_number)
             .with_thread_names(self.display_thread_names)
-            .with_span_events(self.span_events.clone())
-            .with_filter(tracing::level_filters::LevelFilter::from_level(
-                self.max_level,
-            ));
-        if self.log_to_file {
-            tracing_subscriber::registry()
-                .with(layer.and_then({
-                    tracing_subscriber::fmt::layer()
-                        .with_writer(
-                            self.logfile()?
-                                .expect("logging to file is requested but logfile returned None"),
-                        )
-                        .with_ansi(self.ansi)
-                        .with_target(self.display_target)
-                        .with_file(self.display_filename)
-                        .with_thread_ids(self.display_thread_ids)
-                        .with_line_number(self.display_line_number)
-                        .with_thread_names(self.display_thread_names)
-                        .with_span_events(self.span_events.clone())
-                        .with_filter(tracing::level_filters::LevelFilter::from_level(
-                            self.max_level,
-                        ))
-                }))
-                .init();
-        } else {
-            tracing_subscriber::registry().with(layer).init();
+            .with_span_events(FmtSpan::FULL);
+        // I know this is hacky, but I couldn't get it any other way. I couldn't even find a
+        // project that could do it any other way. You can't apply one after another, because the
+        // type is changed every time. When using `Box<dyn Whatever>`, some methods complain about
+        // not being in trait bounds.
+        // TODO: somehow find a better solution for this
+        match (self.log_to_file, self.show_time, self.pretty, self.uptime) {
+            (true, true, true, true) => {
+                let subscriber = subscriber
+                    .with_writer(new_file_appender(self.log_dir))
+                    .with_timer(time::uptime())
+                    .pretty()
+                    .finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (true, true, true, false) => {
+                let subscriber = subscriber
+                    .with_writer(new_file_appender(self.log_dir))
+                    .pretty()
+                    .finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (true, false, true, _) => {
+                let subscriber = subscriber
+                    .with_writer(new_file_appender(self.log_dir))
+                    .without_time()
+                    .pretty()
+                    .finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (true, true, false, true) => {
+                let subscriber = subscriber
+                    .with_writer(new_file_appender(self.log_dir))
+                    .with_timer(time::uptime())
+                    .finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (true, true, false, false) => {
+                let subscriber = subscriber
+                    .with_writer(new_file_appender(self.log_dir))
+                    .finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (true, false, false, _) => {
+                let file_appender = tracing_appender::rolling::daily(self.log_dir.clone(), "log");
+                let (file_writer, _guard) = tracing_appender::non_blocking(file_appender);
+                let subscriber = subscriber.with_writer(file_writer).without_time().finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (false, true, true, true) => {
+                let subscriber = subscriber.pretty().with_timer(time::uptime()).finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (false, true, true, false) => {
+                let subscriber = subscriber.pretty().with_timer(time::uptime()).finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (false, false, true, _) => {
+                let subscriber = subscriber.without_time().pretty().finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (false, true, false, true) => {
+                let subscriber = subscriber.with_timer(time::uptime()).finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (false, true, false, false) => {
+                let subscriber = subscriber.finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (false, false, false, _) => {
+                let subscriber = subscriber.without_time().finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
         }
-
         INITIALIZED.store(true, Ordering::Relaxed);
         Ok(Logger {})
     }
 
-    /// Opens a new file for logging to.
-    ///
-    /// Format: `{log_dir}/{consumer_name}_2024-09-01.log`
-    ///
-    /// Will be none if [`Self::log_to_file`] is [false].
-    fn logfile(&self) -> Result<Option<std::fs::File>> {
-        if !self.log_to_file {
-            return Err(Error::LogfileButNoFilelog.into());
-        }
-        let mut path = self.log_dir.clone();
-        std::fs::create_dir_all(&path)?;
-        path.push(format!(
-            "{}_{}.log",
-            libpt_core::get_crate_name().unwrap_or_else(|| "logfile".to_string()),
-            chrono::Local::now().date_naive()
-        ));
-        let file = std::fs::File::create(path)?;
-        Ok(Some(file))
-    }
-
     /// enable or disable logging to and creating of logfiles
-    ///
-    /// If you want to log to a file, don't forget to set [`Self::log_dir`]!
-    ///
-    /// Default: false
-    #[must_use]
-    pub const fn log_to_file(mut self, log_to_file: bool) -> Self {
+    pub fn log_to_file(mut self, log_to_file: bool) -> Self {
         self.log_to_file = log_to_file;
         self
     }
 
     /// set a directory where logfiles would be created in
     ///
-    /// Enable or disable creation and logging to logfiles with [`log_to_file`](Self::log_to_file).
+    /// Enable or disable creation and logging to logfiles with [log_to_file](Self::log_to_file).
     ///
-    /// Default: [`DEFAULT_LOG_DIR`] (/dev/null)
-    #[must_use]
+    /// The default logdir is [DEFAULT_LOG_DIR].
     pub fn log_dir(mut self, log_dir: PathBuf) -> Self {
         self.log_dir = log_dir;
         self
@@ -225,112 +235,70 @@ impl LoggerBuilder {
     /// are displayed by a program that does not interpret them.
     ///
     /// Keeping ANSI control sequences enabled has the disadvantage of added colors for the logs.
-    ///
-    /// Default: true
-    #[must_use]
-    pub const fn ansi(mut self, ansi: bool) -> Self {
+    pub fn ansi(mut self, ansi: bool) -> Self {
         self.ansi = ansi;
         self
     }
 
     /// when making a log, display the source file in which a log was crated in
-    ///
-    /// Default: false
-    #[must_use]
-    pub const fn display_filename(mut self, display_filename: bool) -> Self {
+    pub fn display_filename(mut self, display_filename: bool) -> Self {
         self.display_filename = display_filename;
         self
     }
 
-    /// when making a log, display the time of the message
-    ///
-    /// Default: true
-    #[must_use]
-    pub const fn display_time(mut self, show_time: bool) -> Self {
-        self.show_time = show_time;
-        self
-    }
-
     /// when making a log, display the log level of the message
-    ///
-    /// Default: true
-    #[must_use]
-    pub const fn display_level(mut self, display_level: bool) -> Self {
+    pub fn display_level(mut self, display_level: bool) -> Self {
         self.display_level = display_level;
         self
     }
 
     /// show target context
-    ///
-    /// Default: false
-    #[must_use]
-    pub const fn display_target(mut self, display_target: bool) -> Self {
+    pub fn display_target(mut self, display_target: bool) -> Self {
         self.display_target = display_target;
         self
     }
 
+    /// set the maximum verbosity level.
+    pub fn max_level(mut self, max_level: Level) -> Self {
+        self.max_level = max_level;
+        self
+    }
+
     /// show the id of the thread that created this message
-    ///
-    /// Default: false
-    #[must_use]
-    pub const fn display_thread_ids(mut self, display_thread_ids: bool) -> Self {
+    pub fn display_thread_ids(mut self, display_thread_ids: bool) -> Self {
         self.display_thread_ids = display_thread_ids;
         self
     }
 
     /// show the name of the thread that created this message
-    ///
-    /// Default: false
-    #[must_use]
-    pub const fn display_thread_names(mut self, display_thread_names: bool) -> Self {
+    pub fn display_thread_names(mut self, display_thread_names: bool) -> Self {
         self.display_thread_names = display_thread_names;
         self
     }
 
     /// show which line in the source file produces a log
-    ///
-    /// Default: false
-    #[must_use]
-    pub const fn display_line_number(mut self, display_line_number: bool) -> Self {
+    pub fn display_line_number(mut self, display_line_number: bool) -> Self {
         self.display_line_number = display_line_number;
         self
     }
 
     /// splits a log over multiple lines, looks like a python traceback
-    ///
-    /// Default: false
-    #[must_use]
-    pub const fn pretty(mut self, pretty: bool) -> Self {
+    pub fn pretty(mut self, pretty: bool) -> Self {
         self.pretty = pretty;
         self
     }
 
+    /// show a timestamp describing when the log was created
+    pub fn show_time(mut self, show_time: bool) -> Self {
+        self.show_time = show_time;
+        self
+    }
+
     /// show timestamps as uptime (duration since the logger was initialized)
-    ///
-    /// Default: false
-    #[must_use]
-    pub const fn uptime(mut self, uptime: bool) -> Self {
+    pub fn uptime(mut self, uptime: bool) -> Self {
         self.uptime = uptime;
         self
     }
-
-    /// set the lowest loglevel to be displayed
-    ///
-    /// Default: [`Level::INFO`]
-    #[must_use]
-    pub const fn set_level(mut self, max_level: Level) -> Self {
-        self.max_level = max_level;
-        self
-    }
-
-    /// set how span events are handled
-    ///
-    /// Default: [`FmtSpan::NONE`]
-    #[must_use]
-    pub const fn span_events(mut self, span_events: FmtSpan) -> Self {
-        self.span_events = span_events;
-        self
-    }
 }
 
 impl Default for LoggerBuilder {
@@ -349,12 +317,11 @@ impl Default for LoggerBuilder {
             pretty: false,
             show_time: true,
             uptime: false,
-            span_events: FmtSpan::NONE,
         }
     }
 }
 
-/// ## Logger for `libpt`
+/// ## Logger for [`pt`](libpt)
 ///
 /// A logger is generally a functionality that let's you write information from your library or
 /// application in a more structured manner than if you just wrote all information to `stdout` or
@@ -366,23 +333,19 @@ impl Default for LoggerBuilder {
 ///
 /// ## Levels
 ///
-/// * [ERROR](Level::ERROR) – Something broke
-/// * [WARN](Level::WARN) – Something is bad
-/// * [INFO](Level::INFO) – Useful information for users
-/// * [DEBUG](Level::DEBUG) – Useful information for developers
-/// * [TRACE](Level::TRACE) – Very verbose information for developers (often for libraries)
+/// TODO: add levels desc and ascii art
 ///
 /// ## Usage
 ///
 /// You don't need to use the [Logger] struct, it's better to use the macros instead:
 ///
-/// * [`error!`]
-/// * [`warn!`]
-/// * [`info!`]
-/// * [`debug!`]
-/// * [`trace!`]
+/// * `error!`
+/// * `warn!`
+/// * `info!`
+/// * `debug!`
+/// * `trace!`
 ///
-/// You can however use the [Logger] struct in cases where usage of a macro is impossible or
+/// You can however use the [Logger] struct in cases where usage of a macro is bad or
 /// you are somehow working with multiple loggers. The macros offer additional functionalities,
 /// suck as full `format!` support and context, see [`tracing`], which we use as backend.
 ///
@@ -402,46 +365,206 @@ pub struct Logger;
 
 /// ## Main implementation
 impl Logger {
-    /// Get a new [`LoggerBuilder`]
-    #[must_use]
+    /// Get a new [LoggerBuilder]
     pub fn builder() -> LoggerBuilder {
         LoggerBuilder::default()
     }
 
+    /// ## initializes the logger
+    ///
+    /// Will enable the logger to be used.
+    ///
+    /// Assumes some defaults, use [`init_customized`](Self::init_customized) for more control
+    #[deprecated(since = "0.4.1", note = "use Logger::builder() instead")]
+    pub fn build(log_dir: Option<PathBuf>, max_level: Option<Level>, uptime: bool) -> Result<Self> {
+        #[allow(deprecated)]
+        Self::build_customized(
+            log_dir.is_some(),
+            log_dir.unwrap_or(PathBuf::from(DEFAULT_LOG_DIR)),
+            true,
+            false,
+            true,
+            false,
+            max_level.unwrap_or(DEFAULT_LOG_LEVEL),
+            false,
+            false,
+            false,
+            false,
+            true,
+            uptime,
+        )
+    }
+
+    /// ## initializes the logger
+    ///
+    /// Will enable the logger to be used. This is a version that shows less information,
+    /// useful in cases with only one sender to the logging framework.
+    ///
+    /// Assumes some defaults, use [`init_customized`](Self::init_customized) for more control
+    #[deprecated(since = "0.4.1", note = "use Logger::builder() instead")]
+    pub fn build_mini(max_level: Option<Level>) -> Result<Self> {
+        #[allow(deprecated)]
+        Self::build_customized(
+            false,
+            PathBuf::from(DEFAULT_LOG_DIR),
+            true,
+            false,
+            true,
+            false,
+            max_level.unwrap_or(DEFAULT_LOG_LEVEL),
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+        )
+    }
+
+    /// ## initializes the logger
+    ///
+    /// Will enable the logger to be used.
+    #[deprecated(since = "0.4.1", note = "use Logger::builder() instead")]
+    #[allow(clippy::too_many_arguments)]
+    pub fn build_customized(
+        log_to_file: bool,
+        log_dir: PathBuf,
+        ansi: bool,
+        display_filename: bool,
+        display_level: bool,
+        display_target: bool,
+        max_level: Level,
+        display_thread_ids: bool,
+        display_thread_names: bool,
+        display_line_number: bool,
+        pretty: bool,
+        show_time: bool,
+        uptime: bool, // uptime instead of system time
+    ) -> Result<Self> {
+        // only init if no init has been performed yet
+        if INITIALIZED.load(Ordering::Relaxed) {
+            warn!("trying to reinitialize the logger, ignoring");
+            bail!(Error::Usage("logging is already initialized".to_string()));
+        }
+        let subscriber = tracing_subscriber::fmt::Subscriber::builder()
+            .with_level(display_level)
+            .with_max_level(max_level)
+            .with_ansi(ansi)
+            .with_target(display_target)
+            .with_file(display_filename)
+            .with_thread_ids(display_thread_ids)
+            .with_line_number(display_line_number)
+            .with_thread_names(display_thread_names)
+            .with_span_events(FmtSpan::FULL);
+        // I know this is hacky, but I couldn't get it any other way. I couldn't even find a
+        // project that could do it any other way. You can't apply one after another, because the
+        // type is changed every time. When using Box<dyn Whatever>, some methods complain about
+        // not being in trait bounds.
+        // TODO: somehow find a better solution for this
+        match (log_to_file, show_time, pretty, uptime) {
+            (true, true, true, true) => {
+                let subscriber = subscriber
+                    .with_writer(new_file_appender(log_dir))
+                    .with_timer(time::uptime())
+                    .pretty()
+                    .finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (true, true, true, false) => {
+                let subscriber = subscriber
+                    .with_writer(new_file_appender(log_dir))
+                    .pretty()
+                    .finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (true, false, true, _) => {
+                let subscriber = subscriber
+                    .with_writer(new_file_appender(log_dir))
+                    .without_time()
+                    .pretty()
+                    .finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (true, true, false, true) => {
+                let subscriber = subscriber
+                    .with_writer(new_file_appender(log_dir))
+                    .with_timer(time::uptime())
+                    .finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (true, true, false, false) => {
+                let subscriber = subscriber.with_writer(new_file_appender(log_dir)).finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (true, false, false, _) => {
+                let file_appender = tracing_appender::rolling::daily(log_dir.clone(), "log");
+                let (file_writer, _guard) = tracing_appender::non_blocking(file_appender);
+                let subscriber = subscriber.with_writer(file_writer).without_time().finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (false, true, true, true) => {
+                let subscriber = subscriber.pretty().with_timer(time::uptime()).finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (false, true, true, false) => {
+                let subscriber = subscriber.pretty().with_timer(time::uptime()).finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (false, false, true, _) => {
+                let subscriber = subscriber.without_time().pretty().finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (false, true, false, true) => {
+                let subscriber = subscriber.with_timer(time::uptime()).finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (false, true, false, false) => {
+                let subscriber = subscriber.finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+            (false, false, false, _) => {
+                let subscriber = subscriber.without_time().finish();
+                tracing::subscriber::set_global_default(subscriber)?;
+            }
+        }
+        INITIALIZED.store(true, Ordering::Relaxed);
+        Ok(Logger {})
+    }
+
     /// ## logging at [`Level::ERROR`]
     pub fn error<T>(&self, printable: T)
     where
         T: fmt::Display,
     {
-        error!("{}", printable);
+        error!("{}", printable)
     }
     /// ## logging at [`Level::WARN`]
     pub fn warn<T>(&self, printable: T)
     where
         T: fmt::Display,
     {
-        warn!("{}", printable);
+        warn!("{}", printable)
     }
     /// ## logging at [`Level::INFO`]
     pub fn info<T>(&self, printable: T)
     where
         T: fmt::Display,
     {
-        info!("{}", printable);
+        info!("{}", printable)
     }
     /// ## logging at [`Level::DEBUG`]
     pub fn debug<T>(&self, printable: T)
     where
         T: fmt::Display,
     {
-        debug!("{}", printable);
+        debug!("{}", printable)
     }
     /// ## logging at [`Level::TRACE`]
     pub fn trace<T>(&self, printable: T)
     where
         T: fmt::Display,
     {
-        trace!("{}", printable);
+        trace!("{}", printable)
     }
 }
 
@@ -463,3 +586,8 @@ impl Default for Logger {
             .expect("building a Logger failed")
     }
 }
+
+fn new_file_appender(log_dir: PathBuf) -> NonBlocking {
+    let file_appender = tracing_appender::rolling::daily(log_dir.clone(), "log");
+    tracing_appender::non_blocking(file_appender).0
+}

members/libpt-py/.gitignore

@@ -0,0 +1,72 @@
+/target
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+.pytest_cache/
+*.py[cod]
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+.venv/
+env/
+bin/
+build/
+develop-eggs/
+dist/
+eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+include/
+man/
+venv/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+pip-selfcheck.json
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.cache
+nosetests.xml
+coverage.xml
+
+# Translations
+*.mo
+
+# Mr Developer
+.mr.developer.cfg
+.project
+.pydevproject
+
+# Rope
+.ropeproject
+
+# Django stuff:
+*.log
+*.pot
+
+.DS_Store
+
+# Sphinx documentation
+docs/_build/
+
+# PyCharm
+.idea/
+
+# VSCode
+.vscode/
+
+# Pyenv
+.python-version

members/libpt-py/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "libpt-py"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+license.workspace = true
+description.workspace = true
+readme.workspace = true
+homepage.workspace = true
+repository.workspace = true
+keywords.workspace = true
+categories.workspace = true
+
+[package.metadata.maturin]
+name = "libpt"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+libpt = { version = "0.5.0"}
+pyo3 = { version = "0.19.0", features = ["full"] }
+anyhow.workspace = true
+
+[features]
+default = ["log", "core", "full"]
+core = []
+full = ["default", "core", "log", "bintols"]
+log = ["libpt/log"]
+bintols = ["libpt/bintols", "log"]

members/libpt-py/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["maturin>=1.4,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "libpt"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Rust",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: Implementation :: PyPy",
+]
+dynamic = ["version"]
+
+[tool.maturin]
+features = ["pyo3/extension-module"]

members/libpt-py/src/bintols/mod.rs

@@ -0,0 +1,76 @@
+use pyo3::prelude::*;
+
+use libpt::bintols as origin;
+
+mod split {
+    use libpt::bintols::split as origin;
+    use pyo3::prelude::*;
+
+    #[pyfunction]
+    pub fn split_int(data: u128) -> Vec<u8> {
+        origin::unsigned_to_vec(data)
+    }
+
+    /// implement a python module in Rust
+    pub fn submodule(py: Python, parent: &PyModule) -> PyResult<()> {
+        let module = PyModule::new(py, "split")?;
+
+        module.add_function(wrap_pyfunction!(split_int, module)?)?;
+
+        parent.add_submodule(module)?;
+        Ok(())
+    }
+}
+
+mod display {
+    use libpt::bintols::display as origin;
+    use pyo3::prelude::*;
+
+    #[pyfunction]
+    pub fn bytes_to_bin(data: &[u8]) -> String {
+        origin::bytes_to_bin(data)
+    }
+
+    #[pyfunction]
+    pub fn byte_bit_display(data: usize) -> String {
+        origin::byte_bit_display(data)
+    }
+
+    #[pyfunction]
+    pub fn humanbytes(total: u128) -> String {
+        origin::humanbytes(total)
+    }
+
+    /// implement a python module in Rust
+    pub fn submodule(py: Python, parent: &PyModule) -> PyResult<()> {
+        let module = PyModule::new(py, "display")?;
+
+        module.add_function(wrap_pyfunction!(bytes_to_bin, module)?)?;
+        module.add_function(wrap_pyfunction!(byte_bit_display, module)?)?;
+        module.add_function(wrap_pyfunction!(humanbytes, module)?)?;
+
+        parent.add_submodule(module)?;
+        Ok(())
+    }
+}
+
+/// implement a python module in Rust
+pub fn submodule(py: Python, parent: &PyModule) -> PyResult<()> {
+    let module = PyModule::new(py, "bintols")?;
+
+    // binary constants
+    module.add("KIBI", origin::KIBI)?;
+    module.add("MEBI", origin::MEBI)?;
+    module.add("GIBI", origin::GIBI)?;
+    module.add("TEBI", origin::TEBI)?;
+    module.add("PEBI", origin::PEBI)?;
+    module.add("EXBI", origin::EXBI)?;
+    module.add("ZEBI", origin::ZEBI)?;
+    module.add("YOBI", origin::YOBI)?;
+
+    display::submodule(py, module)?;
+    split::submodule(py, module)?;
+
+    parent.add_submodule(module)?;
+    Ok(())
+}

members/libpt-py/src/core/mod.rs

@@ -0,0 +1,11 @@
+use pyo3::prelude::*;
+
+mod printing;
+
+/// implement a python module in Rust
+pub fn submodule(py: Python, parent: &PyModule) -> PyResult<()> {
+    let module = PyModule::new(py, "core")?;
+    printing::submodule(py, module)?;
+    parent.add_submodule(module)?;
+    Ok(())
+}

members/libpt-py/src/core/printing.rs

@@ -0,0 +1,24 @@
+use pyo3::prelude::*;
+
+use libpt::core::printing as origin;
+
+/// Quickly get a one line visual divider
+#[pyfunction]
+pub fn divider() -> String {
+    origin::divider()
+}
+
+/// Quickly print a one line visual divider
+#[pyfunction]
+pub fn print_divider() {
+    origin::print_divider()
+}
+
+/// implement a python module in Rust
+pub fn submodule(py: Python, parent: &PyModule) -> PyResult<()> {
+    let module = PyModule::new(py, "printing")?;
+    module.add_function(wrap_pyfunction!(divider, module)?)?;
+    module.add_function(wrap_pyfunction!(print_divider, module)?)?;
+    parent.add_submodule(module)?;
+    Ok(())
+}

members/libpt-py/src/lib.rs

@@ -0,0 +1,30 @@
+//! Python bindings for [`libpt`]
+
+#[cfg(feature = "bintols")]
+mod bintols;
+#[cfg(feature = "core")]
+mod core;
+#[cfg(feature = "log")]
+mod log;
+
+use pyo3::prelude::*;
+
+/// return the version of libpt
+#[pyfunction]
+fn version() -> String {
+    env!("CARGO_PKG_VERSION").to_string()
+}
+
+/// implement a python module in Rust
+#[pymodule]
+#[pyo3(name = "libpt")]
+fn libpt_py(py: Python, m: &PyModule) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(version, m)?)?;
+    #[cfg(feature = "core")]
+    core::submodule(py, m)?;
+    #[cfg(feature = "log")]
+    log::submodule(py, m)?;
+    #[cfg(feature = "bintols")]
+    bintols::submodule(py, m)?;
+    Ok(())
+}

members/libpt-py/src/log/mod.rs

@@ -0,0 +1,91 @@
+use std::path::PathBuf;
+
+use pyo3::prelude::*;
+
+use libpt::log as origin;
+
+#[derive(Clone)]
+#[pyclass]
+pub enum Level {
+    Error,
+    Warn,
+    Info,
+    Debug,
+    Trace,
+}
+
+impl From<Level> for origin::Level {
+    fn from(value: Level) -> Self {
+        match value {
+            Level::Error => origin::Level::ERROR,
+            Level::Warn => origin::Level::WARN,
+            Level::Info => origin::Level::INFO,
+            Level::Debug => origin::Level::DEBUG,
+            Level::Trace => origin::Level::TRACE,
+        }
+    }
+}
+
+#[pyclass]
+pub struct Logger {
+    inner: origin::Logger,
+}
+
+impl From<origin::Logger> for Logger {
+    fn from(inner: origin::Logger) -> Self {
+        Self { inner }
+    }
+}
+
+#[pymethods]
+impl Logger {
+    #[new]
+    pub fn build(
+        log_dir: Option<PathBuf>,
+        max_level: Option<Level>,
+        uptime: Option<bool>,
+    ) -> anyhow::Result<Self> {
+        // concert our wrapper type
+        let max_level = max_level.map(origin::Level::from);
+        let mut builder = origin::Logger::builder();
+        if log_dir.is_some() {
+            builder = builder.log_dir(log_dir.unwrap());
+        }
+        if max_level.is_some() {
+            builder = builder.max_level(max_level.unwrap());
+        }
+        if uptime.is_some() {
+            builder = builder.uptime(uptime.unwrap());
+        }
+        Ok(builder.build()?.into())
+    }
+
+    /// ## logging at [`Level::ERROR`]
+    pub fn error(&self, printable: String) {
+        self.inner.error(printable)
+    }
+    /// ## logging at [`Level::WARN`]
+    pub fn warn(&self, printable: String) {
+        self.inner.warn(printable)
+    }
+    /// ## logging at [`Level::INFO`]
+    pub fn info(&self, printable: String) {
+        self.inner.info(printable)
+    }
+    /// ## logging at [`Level::DEBUG`]
+    pub fn debug(&self, printable: String) {
+        self.inner.debug(printable)
+    }
+    /// ## logging at [`Level::StringRACE`]
+    pub fn trace(&self, printable: String) {
+        self.inner.trace(printable)
+    }
+}
+
+/// implement a python module in Rust
+pub fn submodule(py: Python, parent: &PyModule) -> PyResult<()> {
+    let module = PyModule::new(py, "log")?;
+    module.add_class::<Logger>()?;
+    parent.add_submodule(module)?;
+    Ok(())
+}

scripts/publish.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 set -e
-cargo check --all-features --workspace
+cargo check --all-features
 echo ">>>>>>>> SELECT A NEW VERSION"
 cargo ws version
 NEW_VERSION=$(cat Cargo.toml | rg '^\s*version\s*=\s*"([^"]*)"\s*$' -or '$1')