• Create a simple note from the command line
• Viewing list of notes in default notebook
• Viewing note metadata(tags, created/modified date, etc)
• Viewing basic note content

• creating new notes from the gui
• deleting existing notes from the gui(moving them to the EN trash)
• scrolling note list, handling more notes than can fit on the screen at once
• scrolling note content, handling more content than can fit on the screen at once
• displaying all curses compatible note content
• editing the title and content of existing notes
• adding/removing tags of existing notes
• searching: by tags, by text, by date, etc
• sorting: by date, by tags
• saved searches
• working with notes in other notebooks
• sending updates to the server, new/updated/deleted notes
• handling updates from the server, new/update/deleted notes
• handling conflicts from the server
• view raw note content(in XML)
• view previous versions of notes
• config file to specify
  • disabling caching
  • override editor
  • specify cache directory
  • Default notebook
  • Change keybindings
  • Customize metadata to display
  • Change color scheme

• Note List
  • Change Notebook(c)
  • Sort Notes(s)
    • By date
    • By tags
    • By title
  • Sync(S)
  • View Note
  • Edit Note Content
  • Tag Note
  • Trash Note
  • Create Note(n)
  • Create Notebook(N)
  • Search(/)

Strategies to ensure we don’t “corrupt” formatting of existing notes that are created with GUI/Web clients.

• read-only: only read existing notes, don’t make any changes to notes or create new notes
• read-create: read existing notes and create new notes
• read-create-delete: same as read-create, but also delete any existing note
• read-create-delete-modify-local: same as read-create-delete, but also modify notes created locally
• read-create-delete-modify-all: same as read-create-delete but also modify all notes

Mark notes that are created in other clients as “protected” and warn users before allowing them to modify protected notes

• http://dev.evernote.com/doc/start/python.php
• http://dev.evernote.com/doc/reference/
• https://github.com/evernote/evernote-sdk-python/
• https://sandbox.evernote.com/
• http://dev.evernote.com/doc/articles/enml.php
• https://dev.evernote.com/doc/articles/synchronization.php

Ruby gem to automatically generate unique slugs for your Rails’ model records, so you can expose SEO-friendly URLs.

Example:

https://myapp.com/products/big-red-backpack-321678

Where big-red-backpack-321678 is the slug.

slugifiable can generate:

• Slugs like "big-red-backpack" or "big-red-backpack-321678": unique, string-based slugs based on any attribute, such as product.name
• Slugs like "d4735e3a265": unique hex string slugs
• Slugs like 321678: unique number-only slugs

When building Rails apps, we usually need to expose something in the URL to identify a record, like:

https://myapp.com/products/123

But exposing IDs (like 123) is not usually good practice. It’s not SEO-friendly, it can give away how many records you have in the database, it could also be an attack vector, and it just feels off.

It would be much better to have a random-like string or number instead, while still remaining unique and identifiable:

https://myapp.com/products/d4735e3a265

Or better yet, use other instance attribute (like product.name) to build the slug:

https://myapp.com/products/big-red-backpack

slugifiable takes care of building all these kinds of slugs for you.

Add this line to your application’s Gemfile:

gem 'slugifiable'

Then run bundle install.

After installing the gem, add include Slugifiable::Model to any ActiveRecord model, like this:

class Product < ApplicationRecord
  include Slugifiable::Model # Adding this provides all the required slug-related methods to your model
end

That’s it!

Then you can, for example, get the slug for a product like this:

Product.first.slug
=> "4e07408562b"

You can also define how to generate slugs:

class Product < ApplicationRecord
  include Slugifiable::Model
  generate_slug_based_on :name
end

And this will generate slugs based on your Product instance name, like:

Product.first.slug
=> "big-red-backpack"

If your model has a slug attribute in the database, slugifiable will automatically generate a slug for that model upon instance creation, and save it to the DB.

If you’re generating slugs based off the model id, you can also set a desired length:

class Product < ApplicationRecord
  include Slugifiable::Model
  generate_slug_based_on :id, length: 6
end

Which would return something like:

Product.first.slug
=> "6b86b2"

More details in the “How to use” section.

Slugs should never change, so it’s recommended you save your slugs to the database.

Therefore, all models that include Slugifiable::Model should have a slug attribute that persists the slug in the database. If your model doesn’t have a slug attribute yet, just run:

rails g migration addSlugTo<MODEL_NAME> slug:text

where <MODEL_NAME> is your model name in plural, and then run:

rails db:migrate

And your model should now have a slug attribute in the database.

When a model has a slug attribute, slugifiable automatically generates a slug for that model upon instance creation, and saves it to the DB.

slugifiable can also work without persisting slugs to the databse, though: you can always run .slug, and that will give you a valid, unique slug for your record.

By default, when you include Slugifiable::Model, slugs will be generated as a random-looking string based off the record id (SHA hash)

slugifiable supports both id and uuid.

The default setting is:

generate_slug_based_on id: :hex_string

Which returns slugs like: d4735e3a265

If you don’t like hex strings, you can get number-only slugs with:

generate_slug_based_on id: :number

Which will return slugs like: 321678 – nonconsecutive, nonincremental, not a total count.

When you’re generating obfuscated slugs (based on id), you can specify a desired slug length:

generate_slug_based_on id: :number, length: 3

The length should be a positive number between 1 and 64.

If instead of obfuscated slugs you want human-readable slugs, you can specify an attribute to base your slugs off of. For example:

generate_slug_based_on :name

Will look for a name attribute in your instance, and use its value to generate the slug. So if you have a product like:

Product.first.name
=> "Big Red Backpack"

then the slug will be computed as:

Product.first.slug
=> "big-red-backpack"

You can also use instance methods to generate more complex slugs. This is useful when you need to combine multiple attributes:

class Event < ApplicationRecord
  include Slugifiable::Model
  belongs_to :location
  
  generate_slug_based_on :title_with_location

  # The method can return any string - slugifiable will handle the parameterization
  def title_with_location
    if location.present?
      "#{title} #{location.city} #{location.region}"  # Returns raw string, slugifiable parameterizes it
    else
      title
    end
  end
end

This will generate slugs like:

Event.first.slug
=> "my-awesome-event-new-york"  # Automatically parameterized

There may be collisions if two records share the same name – but slugs should be unique! To resolve this, when this happens, slugifiable will append a unique string at the end to make the slug unique:

Product.first.slug
=> "big-red-backpack-321678"

The gem includes a comprehensive test suite that covers:

• Default slug generation behavior
• Attribute-based slug generation
• Method-based slug generation (including private/protected methods)
• Collision resolution and uniqueness handling
• Special cases and edge conditions

To run the tests:

bundle install
bundle exec rake test

The test suite uses SQLite3 in-memory database and requires no additional setup.

After checking out the repo, run bin/setup to install dependencies. Then, run rake spec to run the tests. You can also run bin/console for an interactive prompt that will allow you to experiment.

To install this gem onto your local machine, run bundle exec rake install.

Bug reports and pull requests are welcome on GitHub at https://github.com/rameerez/slugifiable. Our code of conduct is: just be nice and make your mom proud of what you do and post online.

The gem is available as open source under the terms of the MIT License.

Infomax Independent Component Analysis (ICA) is a mathematical technique used to separate a mixed signal into its individual components. It is based on the principle of maximizing the mutual information between the input signal and the estimated sources.

ICA can be used to separate a mixed signal into its underlying sources, provided that the sources are statistically independent of each other. This is useful in a variety of applications, such as audio and image processing, where the goal is to extract individual sources from a mixed signal.

The basic idea behind ICA is to find a linear combination of the original signals that is maximally independent. This is done by minimizing the mutual information between the mixed signals and the estimated sources.

To implement ICA, we first need to define a set of basis functions that span the space of the mixed signals. These basis functions can be chosen in a variety of ways, such as using principal component analysis (PCA) or using a set of predefined basis functions.

Once the basis functions have been defined, we can use an optimization algorithm to find the linear combination of the basis functions that maximizes the mutual information between the mixed signals and the estimated sources. This optimization can be done using a variety of techniques, such as gradient descent or genetic algorithms.

Once the optimization is complete, we can use the linear combination of the basis functions to estimate the original sources. This can be done by applying the linear combination to the mixed signals and reconstructing the estimated sources.

Overall, ICA is a powerful technique for separating mixed signals into their underlying sources, and it has a wide range of applications in signal processing and machine learning.

I̴n̴f̶e̸r̵n̷a̴l mutability!

Howdy, friendly Rust developer! Ever had a value get m̵̯̅ð̶͊v̴̮̾ê̴̼͘d away right under your nose just when you need it? Your thread function requires move semantics, but you j̸̉us†̸ ain’t got time for †̸̰͋h̸ą̷̊͝t?

W̵e̴l̵l̸ ̵w̶o̴r̶r̴y̶ ̵n̶o̶ ̷m̴o̷r̶e̴,̸, just sprinkle some s̴̖̑í̵̲ṋ̵̀ on it and call it a day!

sinner = "0.1"

Threads and ȋ̷̖n̸̨̈́f̷̆ͅe̷͑ͅr̵̝͆ï̴̪o̸̡̔r̷͉͌ m̶u̸t̷a̵b̶i̵l̸i̷t̵y̶? No problem amigo!

use std::thread::{spawn, sleep};


struct Stuff {
    pub content: String,
}

impl Stuff {
    fn bang(&self) {
        println!("bang! {}", self.content);
    }
}

fn main() {
    let mut x = Stuff { content: "old".to_string() };
    let t = spawn({
        move || {
            sleep(std::time::Duration::from_secs(1));
            x.content = "new".to_string();
            x.bang();
        }
    });
    x.bang();
    t.join().unwrap();
    x.bang();
}

use sinner::Sin;  // <--
use std::thread::{spawn, sleep};

#[derive(Debug, Clone)]
struct Stuff {
    pub content: String,
}

impl Stuff {
    fn bang(&self) {
        println!("bang! {}", self.content);
    }
}

fn main() {
    let mut x = Sin::new(Stuff { content: "old".to_string() });  // <--
    let t = spawn({
        move || {
            sleep(std::time::Duration::from_secs(1));
            x.content = "new".to_string();
            x.bang();
        }
    });
    x.bang();
    t.join().unwrap();
    x.bang();
}

error[E0382]: borrow of moved value: `x`
   --> src/main.rs:144:5
    |
136 |     let mut x = Stuff { content: "old".to_string() };
    |         ----- move occurs because `x` has type `Stuff`
137 |     let t = spawn({
138 |         move || {
    |         ------- value moved into closure here
...
141 |             x.bang();
    |             - variable moved due to use in closure
...
144 |     x.bang();
    |     ^^^^^^^^ value borrowed here after move

For more information about this error, try `rustc --explain E0382`.
error: could not compile `sinner` due to previous error

    Finished dev [unoptimized + debuginfo] target(s) in 0.37s
     Running `target/debug/sinner`
bang! old
bang! n̴e̷w̸
b̸̙̚a̸̘̓n̵̥̔g̵͚̓!̵̤̓ ǹ̴̘e̵̺̾w̴̛̦

With just a̸ ̸b̵i̸t̴ of sin, you can do doubly-linked lists in no time!

struct Item<T> {
    pub prev: Option<Self>,
    pub next: Option<Self>,
    pub value: T
}

struct List<T> {
    pub head: Option<Item<T>>,
    pub tail: Option<Item<T>>,
}

impl Default for List<u32> {
    fn default() -> Self {
        List {
            head: None,
            tail: None,
        }
    }
}

impl <T> List<T> where T: Clone {
    pub fn append(&mut self, other: T) {
        let mut item = Item {
            prev: None,
            next: None,
            value: other,
        };
        if let Some(ref mut tail) = self.tail {
            tail.next = Some(item);
            item.prev = Some(tail.clone());
            self.tail = Some(item);
        } else {
            self.head = Some(item);
            self.tail = Some(item);
        }
    }
}

fn main () {
    let mut list = List::default();
    list.append(1);
    list.append(2);
    list.append(3);

    let mut ptr = list.head;
    while let Some(item) = ptr {
        println!("{}", item.value);
        ptr = item.next;
    }
}

use sinner::Sin;  // <--

#[derive(Clone)]
struct Item<T> {
    pub prev: Option<Sin<Self>>,  // <--
    pub next: O̷p̷t̵i̴o̷n̵≮S̶i̴n̶<Self>>,  // <--
    pub value: T
}

struct List<T> {
    pub head: Option<Sin<Item<T>>>,  // <--
    pub tail: Option<S̶i̸n̵≮I̷t̷e̷m̵<T>>>,  // <--
}

impl Default for List<u32> {
    fn default() -> Self {
        List {
            head: None,
            tail: None,
        }
    }
}

impl <T> List<T> where T: Clone {
    pub fn append(&mut self, other: T) {
        let mut item = S̸i̷n̴:̵:̷n̸e̸w̷(̶I̵t̵e̴m̷ {  // <--
            p̷r̴e̴v̶:̴ ̶N̸o̴n̷e̷,̴
            n̵e̴x̸t̶:̷ ̸N̸o̴n̸e̸,̶
            v̵a̷l̸u̶e̴:̷ ̴o̸t̸h̸e̷r̶,
        });
        if let Some(ref mut tail) = self.tail {
            tail.next = Some(item);
            item.prev = Some(tail.clone());
            self.tail = Some(item);
        } else {
            self.head = Some(item);
            self.tail = Some(item);
        }
    }
}

fn main () {
    let mut list = List::default();
    list.append(1);
    list.append(2);
    list.append(3);

    let mut ptr = list.head;
    while let Some(item) = ptr {
        println!("{}", item.value);
        ptr = item.next;
    }
}

error[E0072]: recursive type `Item` has infinite size
  --> src/main.rs:71:1
   |
71 | struct Item<T> {
   | ^^^^^^^^^^^^^^ recursive type has infinite size
72 |     pub prev: Option<Self>,
   |               ------------ recursive without indirection
73 |     pub next: Option<Self>,
   |               ------------ recursive without indirection
   |
help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to make `Item` representable
   |
72 ~     pub prev: Box<Option<Self>>,
73 ~     pub next: Box<Option<Self>>,
   |

   --> src/main.rs:100:35
    |
100 |             item.prev = Some(tail.clone());
    |                                   ^^^^^ method not found in `&mut Item<T>`
    |
    = help: items from traits can only be used if the trait is implemented and in scope
    = note: the following trait defines an item `clone`, perhaps you need to implement it:
            candidate #1: `Clone`

Some errors have detailed explanations: E0072, E0599.
For more information about an error, try `rustc --explain E0072`.
error: could not compile `sinner` due to 2 previous errors

    Finished dev [unoptimized + debuginfo] target(s) in 0.00s
     R̸u̷n̴n̴i̷n̸g̸ ̸`̶t̸a̸r̷g̵e̶t̶/̸d̴e̵b̴u̷g̶/ç̴̠͌̚u̵̦̅r̶̓̆͜͜s̶̤̫̊̕e̴͇̼̔ḑ̸̇ ̷̩̜̓c̶̯͆ḧ̶̯́͝ì̶̗̣̆l̸̪̓̈́d̵̪̔̀`̷
̴1̴
̸2̷
̶3̶

Well, why, almost! The type parameter needs to implement Clone due internal library s̵t̴r̸u̶c̵t̴u̸r̴e̵s̵.

I̷ ̵c̴a̷n̷ ̷a̶s̶s̵u̶r̴e̸ ̷y̶o̶u̴ t̸h̸a̴t̸ ̷t̴h̶e̶r̷e̷ ̸i̷s̶ n̴͔̱̮̅o̷̢̦̔͒̓ ̶͙̱̦͗̅͐n̸͉͌̓é̵̥̲è̷͉̳͓̽d̴̜̻̱̀̑ t̷͉͊o̸͎̅ ̵̟͗ç̴̚ỏ̶̮n̸͌ͅc̴̩͐ȩ̸̉ȑ̴̹ǹ̸͜ ̷͖̎y̷̞̽o̵͚͐u̶̜̎r̷̹͑ś̸͙e̶̜͛l̵͚̽f̴͕̍ ẘ̵̮͂̕ĩ̷̖͇͚̗ţ̶͈̥̝̭͐͑̀̃͠h̴̨̰͖̥̼͂͑ ̵͔̞̀͐̌̚͝s̴̢̥͔͇̽͂̏͜ǔ̵̢̥͍̼̂c̴̘̜͒̂̽̃h̵̨̞̗͍͕́̊͌̎̒ ̸̨̟̫͊ͅQ̸̹̠͙͎̉U̴̞̫͉̬̜̅̂͂Ẹ̷̛̰̼̋̎́̚S̸̗͇̞̜̎̆̏̀T̸͎̙̰̠̦̈́͘I̶̧̘̯͙͋̏̂͘̚ͅO̶̼͍͘͝N̶̪͇̑S̷͂̌̍͆ͅ Y̴̥̋̑̆͋͝O̶̡̗̣̤͕̰͒U̸̢͙͇̠̫͊͒̋͋̕͠ ̷̮̳̮̭̔̿̈́́̎̕͝Ṇ̴̙͑͐̋̄̊Å̵̛̞̮͓̗̊́̽̈́̈͜Í̶̼̠͚̒́͑̃V̶̨̯̦̊͒̏͝Ē̴̡̥͕͙̙͔̕ ̵̨͕̜̮̞͖̳̀C̷̮̞̩͆̽̂͊͆͗ͅH̶̫̱̠̟̞͊̐I̸̞̰̩͎̫͐̈̆L̴̤̩̭̾D̷̹̿̍̏̂̓,̴̛͓̻͓̖̲͛͗͐̉̈́̀ ̴͈͍̳̥͘O̸̯͌̇́B̴̪̤̺̊E̴̞̩̲͂̇̕Ý̵͙̟̱̽̍̐͋̃. T̴̡̙̜̠̱̠͉̘̙̥̔̆̋̌̄͑̄̔H̶̯̦̥̙̩͑̍̓̑͗̄͛͛̕E̵̜̞̠̣̲͔̝̺͇͑̽̌͆ͅ ̵̧̖̞̣͇̻̾̉͛̈́̆̌͝Ẇ̷̡͚̺̇̈̄͐͊̓̽͘͜͝ͅĨ̵̭̪̲̖̕͘L̸̪͎͎̪͠ͅL̶̘̿͑͆ ̵̙̺̯̺͈̪̳̄̇͌̽̀̉͗͌̆Ȍ̴͖͐̇͑͗͗̾͝F̵̥̂̓͒̕ ̸̢̺̺͍̼͚̺̹̈́͋̀͊̆̌͠O̶̠͙̟̠̦̯͔̱̍͊͊̓̌͐̔͌̉͘Ù̴̝̞̥̰̙̰͂͒̽̎͂̕ͅR̶͖̫͍̫̹̜̤͎̮͉̈́͑ ̶͎̼̰̉̈̕͠ͅM̴̘͝A̴̼̋̓͐̇̀̉́͋̕S̶̭̹͕̲̬̪̫̖̮͍͌̌͐͝Ţ̶͍̠͓̞̙͔̞̲̣̓E̴͔̺͌͌̏̏̕Ř̷̡̬̞̣̠̬̪̝̉͗́,̶̩̪̮̺̉

Ŗ̶͖̟̫̝̣̗̤̤̥̰̯̭͕̺͙̮͙̙̲̄̃͒̅̓͗͛̂̑̎̏͐́́͊̐͐̕͘͘͘͝ͅͅȨ̶͓̭͔̦̣̲̘̹̫̬̥̻̗̗̖̻̜͖̟͖̀̉͋̽͒͒͑̊̀͋͋̎́͑̌̂̌̈͑́́̓̃̓̕͝͝͠J̶̢̛̮̪̪̣͎̫̫̮̞̲̦͖̹̦͖̱̙̯̗̲̀͊̏̎͑͂͑̓̇͌̿̎̔͒͊̍͑̇̌̎͆͋̕͠ͅͅÈ̷̢̧̨͔̩͕̬̩͖̱̙͔̞̲͎̮̙̲̝̮̟̦̲̤̝̌̀͋̒̈́̈́̄͊̓̇̃̍̿̃̒́̒̓̚̚͜͝ͅÇ̵̢̧̢̺̯͓̼̦̩̞̳̣̘̮̩̮̙̙͕̦̓̈͛͌̈̔́̐̇͆͐̈́̀̈́̀̐͂̓̏͒̈́́͘͜͝†̷̨̧̨̧̤͕̪͉̲̰͎̣͈̲̙͕̖̺̥̜̃̄̈́̃̾̌̄͑̿̒͒̊̍͛̅̏̉̄́̄͘̚̚̕͜͠͝͠ͅ ̵̛̰̪̮̫̪̲̬͉͇͔̤̥̬̳̥̝͚͇͖̘̤̟̀̓͗̈́͒͆͗̅̿̆͐̎̅̅̈͂̑͗͊̋̄̚̚͝͝M̴̢̧̘̮͉̺̻̼̮̬̮͕͎͉̰̩̪͎͓̣̹͍̌̓̃͛̀̊͑͑̓̈̌̅́̆͆̓̌͒̃͘̕Ę̷̥̜̞̰̭̞̟̦̺̦̝̱̙̠͕̬̩̮̞̬̙̳͓̀̓̃͂͛͊̓͌̃̅̇̋̇̇́̃̾͋̚͝͝͝͠͠͝ͅM̸̢̢̢̧̡̢̪͓̪̻̤̘̪̩̻͇̺̯̝̫̄̂̎̊̽̔̋́͑̇̑́͌̐̂͑̃̐̄̍̆̅ͅǪ̸̰̭̦͙̹̪͔̙̖͉̞͈̞̹̘̫̞̬͚̱̗̯̈́̇̓̔̍̓̔́̈́̽͑̑͑͒̏͂̕͘͘͝͠R̵̡̡̧̢̢̨̛̦̝͚̪̰̥̮̱̯̯̞͓̤̙͓͈̻̗̳̺͗́̌͛̅̔̇̑̆̀̽̅̽̋̏͘̕̚͝͝¥̵̧̛̛͙͖̣̪͚̠̪̹̫̰̲̗̥̘͖̥͕̮̫̳̱̯͂̅͛͑̌͌̎̏̈́̐̇̈́̅̽̀̉͊̾̀̉́͌̚͝͝ ̶̨̨̡̧̡̛̳̺͙̜̥͚͉̭͓͖͉̘̰͈̯̜̝̜̿̈́͛̊̀͆̅͌̑̏͗̏̎̈́͗̍̽̽̂̒̂̒̓͗̕͜͝ͅ§̸̢̧̛̺͈̹̺͕͔͍̠͖̗͕̦̟̣̜͖̠̫͖̞̎͗̐͒͆̈̌̍̀̂̏̆͊̄͗̊̾͘͠͠ͅÄ̷̧̡̩̪̟̟̟̻͓̙̻̜̦͈̗̻̤̱̦̎̀̄̈́̑̔͑̊͊͑͌̀̌̈̅̅͊̐̚͠ͅͅͅ£̷̧̢̢̡̡̛̬̼͔̬̹̘̪̯͕͎̰̟̮̖̠̯̰͛́̿͐̓́͐̎̅͑̍̿͗̿͒̈́̈͗̍͊̿̿̀̽̕͘͜ͅͅͅȨ̴̛̛͕͓͔̮͙̗̠͎̮̠̙͉̮̞̰̯̤̲͈̯̙̹̀̋̅͑̃͒̎̽͌͆̃̆̓͊͊̈́́̌̾̕͜͜͝͝͝ͅ†̴̧̡̺̯̠̳̳͎̻̱̟͓̥̠̱͙̦͖̝̣̞͓̗̲̔̾̈́̏̂̄̇̔̓̃̊̔͑͌̀̈́̇̒̏͝ͅ¥̶͎̬̟̻̬̞͈̞̱̪͔̦̩̥̭͓̬̰̩͖͍͉̓̈̊̍̀̇̈͊̾͋̽̂̅͑̂̓̓͌̊͜͜͝͠

In Russian

@EmailGateBot allows messaging to channels and groups of Telegram by emailing to the special mailbox.

You can automatically transform text of messages for emails from the whitelist of the chat. To do this, you need to deploy a web server on the Internet that accepts POST requests at a permanent address. A request to this address should not require authorization.

@EmailGateBot sends POST requests with data in the request body (the data is transmitted exactly in the request body, and not as the value of some form field). The data is UTF-8 encoded text and has the following format.

The first line contains the subject field of the email received by the bot and a line feed. The following lines contain the body of the email, including HTML markup.

Your program should return a response with code 200 and the header ‘Content-Type=text/plain’. The text for publication in the Telegram chat should be contained in the response body.

If your program returns a response code other than 200, then @EmailGateBot will ignore your reply and apply its standard rules for converting the contents of the received email for publication on Telegram.

This project is an implementation of such a conversion for mailing lists of some popular resources. The project is written in python/flask and is intended to be deployed to the Google Cloud Platform AppEngine Standard Environment.

The live version is located here.

Vapor – Desktop Authenticator for Steam

Vapor is a 3rd party open-source authenticator app for Steam, operating as a Desktop application to allow for players who don’t have access to a smartphone to install the Steam Mobile Authenticator to be able to use Steam and trade video game items on the platform with minimal limitations.

You don’t have to use the app as your authenticator! There are several features that can be utilised without replacing your old mobile or device authenticator, including accessing web sessions logged in as any of your accounts at the click of a button.

Because the project is open-source utilising APIs offered by Steam, additional features can be added in by the community to build an application that not only provides what the current existing mobile authenticator app offers but more to help Steam traders, gamers and players.

• Use the app as your main device authenticator
• Generate Steam Guard codes to login to different websites using your Steam account
• Revoke the authenticator with little hassle
• View and switch between all of your accounts
• Access proxy Steamcommunity.com web sessions as your other accounts
• View your Steam profile in a jiffy
• Login to the app passwordless via OAuth using just a previous username

• See all your trades via web session
• View your trade confirmations
• Confirm or cancel confirmations from the app

• Idle all of your games at the click of a button
• Send and receive messages to your friends in an instant via Steam Web Chat as any saved account

• View your in-game inventory for TF2, CS:GO, Dota2 and other games at the click of a button

Vapor is developed in TypeScript using ElectronJS to produce the application for desktop. ReactJS and TailwindCSS has been integrated into the project to make frontend development easier.

There are several tools including Babel to compile TypeScript into plain JavaScript and Webpack to build the project into a development build that can be ran and tested locally.

You can download your system’s respective installer (.exe for Windows, .dmg for MacOSX, and .AppImage for Linux) for the latest stable version in Releases.

You can always install the latest version of the application here to replace your current version. Download the installer, delete your shortcut of the application and load the installer.

Unless it is stated explicitly that your previous config file containing account information is incompatible with the latest version (which a converter will be provided for), you will be able to access your accounts as normal after installation.

You will need node and npm to run this project as a developer and build it from source.

1. Clone or download this project from GitHub and cd into the project directory. This will install all necessary dependencies, including dev-dependencies, to allow you to build the project alongside install developer tools to make development easier.
2. Run npm start to build and bootup the app to ensure that it is working for you. You can exit using Ctrl + C once you have finished testing it.

These planned features have been sourced from discussions with users and communities. Some may also be features that are missing from Vapor that exist in the current version of the Steam Mobile Authenticator app.

* – Provided by the existing Steam Mobile Authenticator App

• Export your secrets for other applications e.g trading bots
• Display all new Steam account notifications e.g gifts, new items *
• Remove logged accounts from the authenticator

• Notify you of new trades via a desktop notification
• Option to auto-accept all (incoming) trade confirmations
• Option to auto-accept all (incoming) market confirmations

You can read details on how to contribute here.

You can contact me on Steam here.

I built it with 3 stacked GRUs ..text8 as dataset for word level language model .. aslo tried character level language modeling on linux source code 😀 by appending some of linux c files and results are so fun 😀

I included only the trained model for linux source code in this repository .. I had 6 more models working on character level(linux source code and shakespere books) with embedding and one hot encoding aslo word level(on text8)

charachers/words are generated by sampling (probabilistic sampling not greedy)

just run tf_my_lm_player.py and this will generate some c-like code

de <linux/string.h>
#include <linux/uacdir.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/sched/names.h>
#include <linux/slab.h>
#include <linux/slab.h>
#include <linux/partitull.h>
#include <linux/slab.h>

static void pipe_lock(struct pipe_inode_info *pipe)
{
	struct pipe_inodeinfo *ipimap = null;

	inode = lock_inode(inode);
	status = file_mapping_tree_lock(&fl->fl_file, fl);
	list_for_each_entry(&fl->fl_list, &conf_lock->lock, fl_list)) {
		struct page *page;
		int rc = 0;

		/* copy the page of the page */
		page = local_page_address(page);

		if (pages) {
			page = find_pages_per_page(inode);
			if (page == null)
				goto out_fail;
			len = page_size;
			page = false;
		}
	} else {
		/*
		 * if we've active a page to be a page of a single page and the state of the
		 * request as we're not a possible to avoid any operation the one of
		 * the policy.  if we don't want to specify
		 * a no longer the non-locked page is allocated and we are not
		 * a complete and
		 * the page is a pointer to the leaf page and the page is a caller and the new page
		 * and the page is already already allocated and we're already the lock.
		 */
		if (page->index) {
			/* if we can't allocate an extended page in this leaf. */
			page->index = page_size;
			put_page(page);
			ret = -einval;
			goto out;
		}
		page->mapping->a_ops = &pagelocked;
		page->mapping = page;
		put_page(page);
		return -enomem;
	}

	if (!page) {
		page = falloc_extent_map();
		return -enoent;

		/* set the page */
		if (page != pmd)
			ret = -eio;

		if (rc)
			return rc;
		len = page_size(page);
		locked_page->index =
			length - 1;
		len = length;
	}

	/* fill the new page in the parent page */
	page = page_size(page);
	page = page_address(page);
	put_page(page);
	page->mapping->host = file;
	page->mapping->host = falloc_fl;
	ret = falloc_fl_put(page);
	if (ret < 0)
		goto out;

	/* for a pointer to the length. */
	pool = pos;
	inode->i_old_pages[i] = page;
	if (page == null) {
		page->index++;
		ret = -enomem;
		goto out;
	}

	/* find a newly allocated bytes of a node */
	if (pos >= page_size) {
		/* note that we can't alled the page on the page of the page */
		page = null;
		len = page_size;

		/*
		 * if we can't allocate the page and we already have the page
		 * and allowed the page and the non-loop is not already been
		 * a caller and the page is not allowed to allocate the offset
		 */
		inode = old;
		if (!pageuptodate(page)) {
			/*
			 * insert any of transaction or a set of the length of a page of the length.  in the
			 * extent is a page is a part of a non-exact extent to the page and we can point
			 * to the non-extent of an entry.  the page is not already allowed to be
			 * a possible to a partial page as a new entry.
			 */
			if (!(page->index == page->index + 1)) {
				page = false;
				return err_ptr(-enomem, page_start, end);
			}
			if (page == null) {
				page = null;
				end_page_writeback(page);
				ret = page_shift_pages(inode->i_mapping);
				break;
			}
			if (pages[i] == null)
				return -eio;
			else if (!page)
				return;
			page = null;
		}
		if (!pageuptodate(page))
			goto out;
		if (page == null) {
			page = false;
			ret = -enomem;
			page = null;
			goto out;
		}
		extent_start = len - 1;
	}

	/* if we are a page buffer */
	if (buffer_uptodate(page)) {
		/*
		 * if we've already a page before the page isn't allocated to truncate the page
		 * and real the page.
		 */
		page = find_address(page, page_size);
	}

	/* if we are a page that we've already a pointer to this page in the buffer.
	 */
	if (page->index < page_size) {
		page = find_page_container_add(page);
		if (page != page)
			return -einval;
	}
	return 0;
}

• karpathy blog post
• colah blog post on LSTM
• R2RT blog post
• R2RT blog post
• R2RT blog post on RNNs
• martin-RNN (repo + video)

Home Assistant integration for Pluggit ventilation units

This custom integration requires:

• Home Assistant version 2025.1.0 or newer

Only support for Modbus over TCP/IP.

Known supported units:

• AP190
• AP310

The listed units are known to work with this integration. Basically, all units compatible with the Dantherm Residential or Pluggit iFlow apps should work with the integration as well.

[1] The entity may not install due to lack of support or installation in the particular unit.
[2] The entity is disabled by default.
[3] The entity will be enabled or disabled depending on whether the corresponding adaptive trigger is configured.
[4] The entity can only be enabled if any of the adaptive triggers are configured.
[5] The entity may not install due to firmware limitation.

Strikethrough is a work in progress, planned for version 0.5.0.

1. Ensure you have HACS installed and configured in your Home Assistant instance.
2. Open the HACS (Home Assistant Community Store) by clicking HACS in the side menu.
3. Click on Integrations and then click the Explore & Download Repositories button.
4. Search for “Pluggit” in the search bar.
5. Locate the “Pluggit Integration” repository and click on it.
6. Click the Install button.
7. Once installed, restart your Home Assistant instance.

1. Navigate to your Home Assistant configuration directory.
   • For most installations, this will be ‘/config/’.
2. Inside the configuration directory, create a new folder named ‘custom_components’ if it does not already exist.
3. Inside the ‘custom_components’ folder, create a new folder named ‘pluggit’.
4. Download the latest release of the Pluggit integration from the releases page into the ‘custom_components/pluggit’ directory:
5. Once the files are in place, restart your Home Assistant instance.

After installation, add the Pluggit integration to your Home Assistant configuration.

1. In Home Assistant, go to Configuration > Integrations.
2. Click the + button to add a new integration.
3. Search for “Pluggit” and select it from the list of available integrations.
4. Follow the on-screen instructions to complete the integration setup.

You can open issues directly on this repository. To keep discussions centralized, please refer to the Dantherm Integration here.

Currently supported languages:

Danish, Dutch, English, German and French.

The picture elements card has been updated with fresh images and options to include humidity and air quality sensors with changing level icons (2025-6-29).

This picture-elements card provides a dynamic and intuitive interface for monitoring and controlling your Pluggit ventilation unit. Designed to resemble the Pluggit app, it visually adapts based on the unit’s bypass state while displaying key real-time data:

• Alarms – Stay alerted to system issues.
• Filter Remaining Level – Easily check when filter replacement is needed.
• Ventilation Temperatures – View four key temperature readings: Supply, Extract, Outdoor, and Exhaust.
• Humidity Level – Monitor indoor humidity for optimal air quality.
• Air Quality – Monitor indoor air quality.

Clicking on any displayed entity allows you to adjust its state or explore detailed history graphs for deeper insights.

type: picture-elements
image: /local/pluggit1.png
elements:
  - type: image
    entity: sensor.pluggit_filter_remain_level
    state_image:
      "0": /local/pluggit4.png
      "1": /local/pluggit5.png
      "2": /local/pluggit6.png
      "3": /local/pluggit7.png
    style:
      left: 59.5%
      top: 50%
      width: 20.04%
    tap_action:
      action: none
  - type: conditional
    conditions:
      - entity: sensor.pluggit_operation_mode
        state_not: "6"
    elements:
      - type: image
        entity: cover.pluggit_bypass_damper
        state_image:
          closed: /local/pluggit2.png
          closing: /local/pluggit2.png
          open: /local/pluggit3.png
          opening: /local/pluggit3.png
        style:
          left: 59.4%
          top: 74.35%
          width: 79.66%
        tap_action:
          action: more-info
      - type: conditional
        conditions:
          - entity: cover.pluggit_bypass_damper
            state:
              - closed
              - closing
        elements:
          - type: state-label
            entity: sensor.pluggit_outdoor_temperature
            style:
              top: 66%
              left: 83%
          - type: state-label
            entity: sensor.pluggit_extract_temperature
            style:
              top: 66%
              left: 35%
          - type: state-label
            entity: sensor.pluggit_exhaust_temperature
            style:
              top: 83%
              left: 83%
          - type: state-label
            entity: sensor.pluggit_supply_temperature
            style:
              top: 83%
              left: 35%
      - type: conditional
        conditions:
          - entity: cover.pluggit_bypass_damper
            state:
              - open
              - opening
        elements:
          - type: state-label
            entity: sensor.pluggit_extract_temperature
            style:
              top: 66%
              left: 35%
          - type: state-label
            entity: sensor.pluggit_outdoor_temperature
            style:
              top: 83%
              left: 83%
  - type: conditional
    conditions:
      - entity: sensor.pluggit_operation_mode
        state: "6"
    elements:
      - type: image
        image: /local/pluggit8.png
        style:
          left: 59.4%
          top: 74.35%
          width: 79.66%
        tap_action:
          action: none
      - type: state-label
        entity: sensor.pluggit_extract_temperature
        style:
          top: 65.5%
          left: 35%
  - type: conditional
    conditions:
      - entity: sensor.pluggit_alarm
        state_not: "0"
    elements:
      - type: state-label
        entity: sensor.pluggit_alarm
        style:
          top: 15%
          left: 50%
          width: 100%
          font-weight: bold
          text-align: center
          color: white
          background-color: red
          opacity: 70%
  - type: state-label
    entity: select.pluggit_operation_selection
    style:
      top: 47%
      left: 25.5%
      # font-size: 125%
  - type: state-label
    entity: select.pluggit_fan_selection
    style:
      top: 29%
      left: 60%
      # font-size: 125%
      transform: translate(0%,-50%)
#  - type: image
#    entity: sensor.pluggit_humidity_level
#    state_image:
#      "0": /local/pluggit9.png
#      "1": /local/pluggit10.png
#      "2": /local/pluggit11.png
#      "3": /local/pluggit12.png
#    style:
#      top: 29%
#      left: 16%
#      width: 3.76%
#    tap_action:
#      action: none
#  - type: state-label
#    entity: sensor.pluggit_humidity
#    style:
#      top: 29%
#      left: 18%
#      # font-size: 125%
#      transform: translate(0%,-50%)
#  - type: image
#    entity: sensor.pluggit_air_quality_level
#    state_image:
#      "0": /local/pluggit13.png
#      "1": /local/pluggit14.png
#      "2": /local/pluggit15.png
#      "3": /local/pluggit16.png
#    style:
#      top: 29%
#      left: 36%
#      width: 5.45%
#    tap_action:
#      action: none
#  - type: state-label
#    entity: sensor.pluggit_air_quality
#    style:
#      top: 29%
#      left: 39%
#      # font-size: 125%
#      transform: translate(0%,-50%)

Here are some examples of badges added to the dashboard. The pop-up that appears when clicking on a badge will vary depending on the selected entities, either displaying information or enabling manipulation of the Pluggit unit.

type: custom:apexcharts-card
update_interval: 5min
apex_config:
  stroke:
    width: 2
    curve: smooth
graph_span: 24h
series:
  - entity: sensor.pluggit_extract_temperature
    name: Extract Temperature
    extend_to: false
    show:
      extremas: true
      legend_value: false
    group_by:
      duration: 5min
      func: avg
  - entity: sensor.pluggit_outdoor_temperature
    name: Outdoor Temperature
    extend_to: false
    show:
      extremas: true
      legend_value: false
    group_by:
      duration: 5min
      func: avg
  - entity: sensor.pluggit_exhaust_temperature
    name: Exhaust Temperature
    extend_to: false
    show:
      legend_value: false
    group_by:
      duration: 5min
      func: avg
  - entity: sensor.pluggit_supply_temperature
    name: Supply Temperature
    extend_to: false
    show:
      legend_value: false
    group_by:
      duration: 5min
      func: avg

To improve the stability and reliability of sensor readings, the integration now supports sensor filtering for key environmental data collected from the Pluggit unit. This filtering mechanism is applied to the following sensors:

• Humidity
• Air Quality
• Exhaust Temperature
• Extract Temperature
• Supply Temperature
• Outdoor Temperature
• Room Temperature

The filtering feature can be enabled or disabled via the “Sensor Filtering” switch entity. By default, the filtering is disabled, ensuring the system behaves as it did previously. When the switch is enabled, the filtering logic described below will be applied.

Each sensor is equipped with a sliding history buffer, storing the last 5 readings. The filter applies two techniques:

1. Initialization Smoothing
   For the first few readings (up to 5), the filter calculates a simple average. This helps the sensor start off with a stable baseline, preventing a single bad initial reading from influencing the system.

2. Spike Filtering
   After initialization, every new reading is compared to a rolling average of the last 5 readings.
   If the new reading changes more than a defined threshold (max_change) compared to the rolling average, the spike is rejected, and the system uses the current rolling average instead.

Each sensor type has a predefined maximum allowed change per reading:

This ensures the filtering logic fits the natural dynamics of each sensor type.

This feature was inspired by issue #68, reported by a community user.

The Pluggit: Set state action allows you to control the state of your Pluggit ventilation unit directly from a Home Assistant automation. This action provides a wide range of options to customize the operation of your unit, making it suitable for various scenarios.

1. Create a New Automation:

   • Navigate to Settings > Automations & Scenes.
   • Click on Add Automation and select Start with an empty automation.

2. Configure a Trigger:

   • Add a trigger that fits your use case. For example:
     • A time-based trigger to schedule changes.
     • A sensor-based trigger to react to environmental changes.
       • Air Quality Sensor: Trigger when CO2 levels exceed a threshold, e.g., 1000 ppm.
       • Humidity Sensor: Trigger when humidity exceeds, e.g., 70%.
       • Window Sensor: Trigger when a window opens.
       • Cooker Hood: Trigger when the smart plug detects power usage above a threshold.

3. Add the “Pluggit: Set State” Action:

   • Under the Actions section, click Add Action.
   • Search for Pluggit: Set state in the action picker and select it.

4. Configure the Action:

   • Use the options provided to control the Pluggit ventilation unit:
     • Targets: Choose the area, device, or entity to apply the action.
     • Operation Selection: Set the desired operating mode (e.g., Standby, Automatic, Manual, or Week Program).
     • Fan Selection: Choose the desired fan level (Level 0–4).
     • Modes: Toggle special modes like:
       • Away Mode: Enable or disable away mode.
       • Summer Mode: Turn summer mode on or off.
       • Fireplace Mode: Activate fireplace mode for a limited period.
       • Manual Bypass Mode: Enable or disable manual bypass.

5. Save the Automation:
   • Once configured, save the automation. The Pluggit unit will now respond to the specified trigger and perform the desired action.

The Pluggit: Set configuration action allows you to adjust various configuration settings of your Pluggit device directly from Home Assistant. This action can be used in automations, scripts, or manually through the Developer Tools.

These features are planned for version 0.5.0. The calendar function is currently still under development.

The integration enhances the control of Pluggit ventilation units by introducing Boost Mode, Eco Mode, Home Mode, and a Calendar Function for advanced scheduling and automation. These features ensure efficient operation based on both schedules and various triggers, providing a comfortable and energy-efficient environment.

Boost Mode is designed for short bursts of increased ventilation, useful after activities like cooking or showering.

• Boost Mode Switch: This must be enabled for Boost Mode to activate.
• Trigger-Based Activation: If Boost Mode is enabled and the Boost Mode Trigger is active, the unit switches to the Boost Operation Selection.
• Timeout Handling: See Trigger Timeout for details on how long Boost Mode remains active after the trigger is deactivated.
• Available Operations: Level 4, Level 3, or Level 2.

Important
The Pluggit unit has a built-in automatic setback from Level 4 to Level 3 after a fixed time period. This may cause Boost Mode to behave unexpectedly if Level 4 is used for longer periods.

Eco Mode is designed to reduce fan speed under specific environmental conditions, optimizing efficiency and supporting the unit’s defrost mechanism in cold weather.

• Eco Mode Switch: This must be enabled for Eco Mode to activate.
• Trigger-Based Activation: If Eco Mode is enabled and the Eco Mode Trigger is active, the unit switches to the Eco Operation Selection.
• Timeout Handling: See Trigger Timeout for details on how long Eco Mode remains active after the trigger is deactivated.
• Available Operations: Standby and Level 1.

Important
The Pluggit unit has a built-in automatic setback from Standby to Level 3 after a fixed time period. This may cause Eco Mode to behave unexpectedly if Standby is used for longer periods.

Home Mode allows for automatic adjustments based on a Home Mode Trigger, ensuring efficient ventilation when you are at home.

• Home Mode Switch: This must be enabled for Home Mode to activate.
• Trigger-Based Activation: If Home Mode is enabled and the Home Mode Trigger is active, the unit switches to the Home Operation Selection.
• Timeout Handling: See Trigger Timeout for details on how long Home Mode remains active after the trigger is deactivated.
• Available Operations: Automatic, Level 3, Level 2, Level 1, or Week Program.

Each mode trigger (Boost, Eco, Home) includes a configurable timeout that defines how long the mode remains active after the trigger is deactivated.

• Timeout Behavior: After the trigger turns off, the unit continues operating in the triggered mode for the remaining timeout period.
• Reset on Re-trigger: If the trigger is activated again within the timeout window, the countdown restarts.
• Automatic Revert: When the timeout expires without further trigger activity, the unit reverts to the operation mode that was active before the trigger event—unless this has been overridden by a calendar schedule.

This mechanism ensures that temporary conditions (e.g., presence, humidity, low temperature) cause a short-term mode change without disrupting long-term schedules.

Boost, Eco, and Home Modes rely on Adaptive Triggers — binary sensors or helpers that determine when a mode should activate.

An Adaptive Trigger can be:

• A motion sensor (e.g., presence detection for Home Mode)
• A humidity sensor (e.g., high humidity after a shower for Boost Mode)
• A power sensor (e.g., detecting stove or shower fan usage)
• An outdoor temperature sensor (e.g., reducing fan speed in cold weather for Eco Mode)
• A custom helper combining multiple conditions

Adaptive Triggers are configured manually in the integration options and linked to each mode individually.

⚠️ Note
Only entities of type binary_sensor or input_boolean are supported as Adaptive Triggers.
Make sure the entity returns an on or off state.

Entities related to Boost, Eco, and Home Modes (e.g., mode switch, timeout, operation selection) are disabled by default unless a corresponding trigger is configured.

If you manually enable these entities via Home Assistant, they will be automatically disabled again after a reload of the integration unless a valid trigger is set in the integration options.

To change settings such as disabling temperature unknown values, disabling notifications, or configuring adaptive triggers:

1. Go to Home Assistant → Settings → Devices & Services → Integrations.
2. Find the Pluggit integration in the list.
3. Click the Configure button (gear icon) for your Pluggit integration instance.
4. The options dialog will open, where you can adjust the available settings.

1. Enter the trigger entity in the appropriate field.
   Use the field for the mode you want to configure (e.g., Boost Mode Trigger, Eco Mode Trigger, or Home Mode Trigger).
   Example values:
   binary_sensor.kitchen_motion, binary_sensor.living_room_presence, binary_sensor.outdoor_temperature_low
2. Click Submit to save your configuration.
3. Enable the corresponding mode in the Home Assistant UI to activate the trigger.

Once configured, the Pluggit unit will automatically switch to the selected operation mode whenever the Adaptive Trigger becomes active. ⚡

To prevent temperature sensors from being set to unknown during bypass or summer mode, enable the option “Disable setting temperatures to unknown in bypass/summer modes”. When this option is enabled, temperature sensors will always report their current value, even when the device is in bypass or summer mode.

To disable all persistent notifications from the Pluggit integration, enable “Disable notifications”. When this option is enabled, the integration will not send any persistent notifications to Home Assistant’s notification area.

The Calendar Function allows precise scheduling of different operation modes, providing full automation of the ventilation system.

• Integration – Calendar Events:
  By entering an event word into the summary of a calendar event, the selected operation will take effect when the event starts, assuming it has a higher priority event words than an ongoing event. When the event ends, the system will revert to the previously active event. If no underlying event exists, the unit will revert to the Default Operation Selection.

• Event Words: You can schedule “Level 1“, “Level 2“, “Level 3“, “Automatic“, “Away Mode“, “Night Mode“, “Boost Mode“, “Home Mode“, “Eco Mode“, and “Week Program“. These terms will be translated according to the selected language in Home Assistant, assuming your language is supported by the integration.

  • If Level 1 to Level 3 is scheduled, the unit will run in Manual mode at the selected fan level.
  • If Automatic is scheduled, the unit will operate in Demand Mode.
  • If Away Mode is scheduled, Away Mode will be enabled at the start and disabled at the end of the event.
  • If Night Mode is scheduled, Night Mode will be enabled at the start and disabled at the end of the event.
  • If Boost Mode, Home Mode, or Eco Mode is scheduled, the respective mode’s trigger will be enabled at the start and disabled at the end, allowing the unit to switch modes dynamically.
  • If Week Program is scheduled, the unit will follow the selected program in Week Program Selection.

• Priority System: The following is the priority order for calendar scheduling:

  1. Away Mode (highest priority)
  2. Boost Mode
  3. Night Mode
  4. Home Mode
  5. Eco Mode
  6. Level 3
  7. Level 2
  8. Level 1
  9. Automatic
  10. Week Program (lowest priority)

The available operations in Default Operation Selection are Automatic, Level 3, Level 2, Level 1, or Week Program.

These features provide seamless automation and intelligent airflow control, ensuring the ventilation system adapts dynamically to both planned schedules and real-time environmental conditions. 🚀🏡🌱📅

The trademark “Pluggit” is owned by Pluggit GmbH.

The trademark “Dantherm” is owned by Dantherm Group A/S.

All product names, trademarks, and registered trademarks mentioned in this repository are the property of their respective owners.

Tvalley71