DEV Community: Pluri45

Leverage in the Predictions Market.

Pluri45 — Sun, 15 Feb 2026 18:54:46 +0000

What is the Prediction Market?

Prediction markets are event contracts that let you buy a share of the outcome of an event. Platforms like Polymarket and Kalshi allow traders to buy and sell event outcome contracts, with the companies collecting fees on each trade. While these markets have proven the thesis that people want to put capital behind their beliefs about the future, they lack many tools available in mature traditional financial markets. Chief among these missing tools is leverage.

What is the impact of Leverage in trading?

Leverage can be described as a loan (margin) that allows a trader to allocate more capital to a trading position in a bid to make a huge profit on the position, and a quiet acceptance of the probability of a loss. For example, a 10x leverage on a $100 trading position means, a trader has a $1000 position on the trade, 10xing their potential rewards. This has been a difficult tool to offer traders in the predictions market.

Why has it been difficult to provide Leverage in Predictions market?

Leverage is a tricky concept in prediction markets due to gap risk-

the risk that a financial instrument's price would dramatically jump (either up or down) from one trade to the next without any trading in between.

Prediction markets have three unique characteristics that make them fundamentally different from traditional assets:

There is a clear upper limit.

The maximum value of a "YES" or “No” share is always $1. If you buy at $0.7, the maximum upside is only 42.85%.

The lower limit is zero.

The trader’s position doesn't decay slowly over time. It either succeeds or goes to zero.

Binary Outcomes.

There is no gradual price discovery process. A sports match might be undecided one moment and be definitely resolved in the next hour. The price doesn't slowly rise, it jumps there.

This is fundamentally different from traditional assets like Bitcoin. A move from $100,000 to $70,000 is marked by stops and pauses. E.g $100K to $92K, back to $95k, $80k, then $70K, making it possible for the liquidation engine to intervene and close your position.

In prediction markets, this gradual process doesn't exist. The nature of the market makes it difficult for leverage providers to handle mass liquidation events because they can't exit trades at favorable prices before events resolve.

Who is actively solving this problem?

The team at Ultramarkets is building a leverage layer for prediction markets. They are solving the gap risk problem through temporal arbitrage. Ultramarkets force all leveraged trades to close before the actual event happens. Traders can still make money from price changes as news comes in and people's opinions shift. But everyone must exit their positions before the event is decided. This way, traders avoid the dangerous moment when the price suddenly jumps to $1 or $0.

Ultramarkets can implement this solution because they operate as a separate layer rather than being built into the prediction market platforms themselves. If Polymarket or Kalshi tried to add leverage directly, they'd face a difficult choice: either keep positions open until events resolve (risking major losses) or close positions early (which would upset traders and create an inconsistent user experience). As an independent leverage provider, Ultramarkets sidesteps this problem entirely: their whole business model is built around closing positions before resolution.

The platform is deliberately choosy about which markets get leverage, and this selectivity is actually a strength. They only support markets with strong liquidity, providing them with enough time before resolution to manage risk properly. Since prediction markets follow a pattern where a small number of popular markets attract most of the trading activity, focusing on these high-volume markets means they're still capturing the majority of demand.

If this approach proves successful at scale, Ultramarkets could become a breakout success in the prediction market ecosystem, unlocking a unicorn level of success.

Building on the Stellar Blockchain

Pluri45 — Wed, 26 Feb 2025 19:42:19 +0000

Introduction

I was working in a team that was building a crypto payment gateway and have been going through a lot of reading regarding the Stellar blockchain. I used to think payments were a solved problem across the world, but now it seems I know so little about the world.

If you were to travel to another nation for tourism or education, you'd have a problem where you'd have to exchange your native currency with the new nation's legal tender. This issue is more serious if your earnings are from your native country. For example, if you have parents or a business at home that finances your lifestyle in the new country, every time they send you money, you will have to withdraw it and look for a local exchanger who will give you an equivalent value in the local currency.

This exchange of currency is usually manual and expensive, as the local exchanger applies a large spread on the exchange due to the low liquidity or demand for your currency. This has been a persistent issue, but the Stellar Blockchain is creating the groundwork for startups to resolve the problem.

What is the Stellar Blockchain?

The Stellar Blockchain is an open, decentralized blockchain platform designed to facilitate cross-border payments. It was founded in 2014 by Jed McCaleb (co-founder of Ripple) and the Stellar Development Foundation (SDF).

The blockchain attempts to bring real-world usage for cryptocurrencies. It has partnered with MoneyGram and enables users to send Stellar tokens (XLM) and USDC and then receive cash in the real world.

This is a great step towards having some of the activities of traditional banks (withdrawals and deposits) mirrored by cryptocurrencies.

Why Stellar?

Stellar supports multiple currencies, with support for fiat-to-cryptocurrency exchange and support for issuing custom tokens. Exchanging African currencies like the Kenyan Shilling (KES) to Nigerian Naira (₦) without using the US dollar is now difficult.

If the central banks of such countries create digital money on blockchains such as Stellar, it will be less expensive than getting all African countries to unite to create an exchange through which they can trade with each other. Doing the same on Stellar facilitates trades between respective countries, enabling cross-border trading - one of the fundamental properties needed for the product that I described in the introduction.

Finally, one of the most important features of the Stellar blockchain is the Stellar Consensus Protocol (SCP).

Stellar Consensus Protocol (SCP):

The Stellar Consensus Protocol (SCP) is a consensus protocol used by the Stellar network to confirm transactions quickly and efficiently. Unlike traditional Proof-of-Work (Bitcoin) or Proof-of-Stake (Ethereum) systems, SCP uses Proof-of-Agreement, a network of trusted nodes which agree on the state of the blockchain, enabling quick transaction confirmation.

SCP relies on the Federated Byzantine Agreement (FBA) protocol model, which provides nodes with a choice of what other nodes to trust and that promotes open membership in the network as well as decentralization. The trust mechanism is flexible in that any participant can be used as a validating node without drawing on large computing resources.

Stellar Use Cases

Cross-Border Payments

Stellar is widely used for remittances and international money transfers due to its speed and low cost.

Tokenization

Stellar allows the creation of digital tokens representing real-world assets, such as stablecoins (e.g., USDC), security tokens, or even NFTs. Asset management firms like Franklin Templeton, WisdomTree Gold, and ABN AMRO issue representations of real-world assets (RWAs) on the Stellar blockchain. These efforts are paving the way for a more inclusive investment environment, enabling people to access assets that were once out of reach due to geographical barriers or limited brokerage options.

Conclusion

The potential of Stellar to really improve cross-border payments and tokenization is tremendous. Stellar employs proof of Agreement rather than proof-of-work or proof-of-stake for transaction validation. Proof of agreement is a network of trusted nodes agreeing on the blockchain state. Stellar's partnerships with big financial institutions and its ability to enable real-world assets (RWAs) on the blockchain reflect its reach in offering financial inclusion.

Building a Compiler & Interpreter in Rust! Part 3

Pluri45 — Wed, 26 Feb 2025 19:06:16 +0000

Building a Compiler & Interpreter in Rust! Part 3

Welcome to Part 3 of our series on Building a Compiler & Interpreter in Rust! In this installment, you'd dive into the heart of the interpreter, focusing on how it processes bytecode instructions and manages data during execution.

You’ll explore the core components of the interpreter, including the Value and Stack structures for data storage, the InterpreterError enum for error handling, and the Virtual Machine (VM) that ties everything together. Additionally, you’ll look at how instructions are encoded and decoded for efficient execution. If you’re new to the series, be sure to catch up with Part 1 and Part 2 to get up to speed. Let’s get started!

Interpreters

The interpreter processes bytecode instructions and executes them sequentially. Remember, the bytecode is the low-level representation of program instructions gotten from the compiler.

Value and Stack Management

Construct the Value enum and Stack struct to handle data storage and manipulation. A Stack is a data structure used to store intermediate values during execution.

// Import necessary modules and crates
use crate::instr::Instr;       // Instruction module for decoding/encoding instructions
use crate::op::Op;             // Operation module for supported opcodes
use thiserror::Error;          // Provides an easy way to define custom error types
use std::io::Write;            // For handling I/O operations
use log::{debug, info, error}; // Logging macros for debugging and error reporting

/// Represents a value in the virtual machine (VM).
/// Currently supports only integer values.
#[derive(Debug, Clone)]
pub enum Value {
    Integer(i64), // Variant for storing integer values
}

impl Value {
    /// Attempts to retrieve the integer value from `Value`.
    /// 
    /// # Returns
    /// - `Ok(i64)` if the `Value` is an integer.
    /// - `Err(InterpreterError::InvalidType)` if the `Value` is not an integer.
    pub fn as_integer(&self) -> Result<i64, InterpreterError> {
        match self {
            Value::Integer(val) => Ok(*val), // Successfully returns the integer
            _ => Err(InterpreterError::InvalidType(
                Value::Integer(0), // Expected type
                self.clone(),      // Actual value causing the error
            )),
        }
    }
}

The Value struct represents data as integers (Value::Integer). It includes methods like as_integer() to safely extract integers. The Stack struct serves as the execution stack:

use crate::instr::Instr;
use crate::op::Op;
use thiserror::Error;
use std::io::Write;
use log::{debug, info, error};

#[derive(Debug)]
pub struct Stack {
    data: Vec<Value>,
}

impl Stack {
    /// Creates a new, empty `Stack`.
    pub fn new() -> Self {
        Self { data: Vec::new() }
    }

    /// Pushes a `Value` onto the stack.
    pub fn push(&mut self, value: Value) {
        self.data.push(value);
    }

    /// Pops the top `Value` from the stack. Returns `None` if the stack is empty.
    pub fn pop(&mut self) -> Option<Value> {
        self.data.pop()
    }

    /// Peeks at the top `Value` without removing it.
    pub fn peek(&self) -> Option<&Value> {
        self.data.last()
    }

    /// Provides mutable access to the top `Value`.
    pub fn back_mut(&mut self) -> Option<&mut Value> {
        self.data.last_mut()
    }

    /// Provides immutable access to the top `Value` (alias for `peek`).
    pub fn back(&self) -> Option<&Value> {
        self.peek()
    }

    /// Pushes a `Value` onto the stack (alias for `push`).
    pub fn push_back(&mut self, value: Value) {
        self.push(value);
    }
}

InterpreterError enum represents different kinds of errors that can occur in a program during program execution, especially those involved with a virtual machine(VM). Each variant of the enum represents a specific kind of error, with associated data or messages to provide more details.

use crate::instr::Instr;
use crate::op::Op;
use thiserror::Error;
use std::io::Write;
use log::{debug, info, error};

#[derive(Debug, Error)]
pub enum InterpreterError {
    /// Error when the provided byte length is not divisible by 8.
    #[error("Invalid number of bytes: {0} (must be divisible by 8)")]
    InvalidNumberOfBytes(usize),

    /// Error when attempting to pop from an empty stack.
    #[error("Stack empty")]
    StackEmpty,

    /// Error when a value type does not match the expected type.
    #[error("Invalid type: Expected {0:?}, got {1:?}")]
    InvalidType(Value, Value),

    /// Error when a division by zero is attempted.
    #[error("Division by zero")]
    DivByZero,

    /// Error when a modulo operation is attempted with a zero divisor.
    #[error("Modulo by zero")]
    ModByZero,
}

Virtual Machine (VM)

The VM struct represents the interpreter:

// Define a virtual machine (VM) struct that contains a stack and bytecode.
pub struct VM {
    stack: Stack,          // Stack to store values during execution
    bytecode: Vec<u64>,    // Bytecode instructions to execute
}

impl VM {
    // Constructor for the VM, initializes an empty stack and bytecode.
    pub fn new() -> Self {
        Self {
            stack: Stack::new(),
            bytecode: Vec::new(),
        }
    }

    // Executes the provided bytecode instructions.
    pub fn execute(&mut self, bytecode: Vec<u64>) -> anyhow::Result<()> {
        self.bytecode = bytecode; // Load the bytecode into the VM
        let mut pc = 0;          // Program counter to track the current instruction

        // Macro to handle operations, printing the operation name and executing the associated function.
        macro_rules! handle_op {
            ($name:expr, $func:expr) => {
                println!("> {}", $name); // Print the operation name
                $func()?;               // Execute the operation and propagate errors
            };
        }

        // Main execution loop: processes each instruction in the bytecode.
        while pc < self.bytecode.len() {
            let instr = Instr::from_u64(self.bytecode[pc]); // Decode the current instruction
            let mut next_pc = pc + 1;                      // Default next instruction is the next one

            debug!(">> stack: {:?}", self.stack); // Debug print the stack state

            // Match the operation and execute the corresponding logic
            match instr.op {
                Op::Push => handle_op!("Push", || Ok(self.stack.push(Value::Integer(instr.value as i64)))),
                Op::Pop => handle_op!("Pop", || self.stack.pop().ok_or(InterpreterError::StackEmpty.into())),
                Op::Inc => handle_op!("Inc", || self.modify_top(|v| *v += 1)),
                Op::Add => handle_op!("Add", || self.binary_op(|a, b| a + b)),
                Op::Mul => handle_op!("Mul", || self.binary_op(|a, b| a * b)),
                Op::Div => handle_op!("Div", || self.checked_op(|a, b| b != 0, |a, b| a / b, "DivByZero")),
                Op::Mod => handle_op!("Mod", || self.checked_op(|a, b| b != 0, |a, b| a % b, "ModByZero")),
                Op::Dup => handle_op!("Dup", || self.stack.back().map(|v| self.stack.push(v.clone())).ok_or(InterpreterError::StackEmpty.into())),
                Op::Print => handle_op!("Print", || self.stack.peek().and_then(|v| v.as_integer().ok()).map(|v| println!("{}", v)).ok_or(InterpreterError::StackEmpty.into())),
                Op::Jmp => handle_op!("Jmp", || { next_pc = instr.value as usize; Ok(()) }),
                Op::Halt => { println!("> Halt"); return Ok(()); }, // Halt execution
                _ => todo!("Unhandled Op::{:?}", instr.op),        // Handle unimplemented operations
            }

            pc = next_pc; // Move to the next instruction
        }

        Ok(()) // Execution completed successfully
    }

    // Modifies the top value on the stack using the provided function.
    fn modify_top(&mut self, f: impl FnOnce(&mut i64)) -> anyhow::Result<()> {
        self.stack
            .back_mut()
            .and_then(|v| v.as_integer_mut())
            .map(f)
            .ok_or(InterpreterError::StackEmpty.into())
    }

    // Performs a binary operation on the top two values of the stack.
    fn binary_op(&mut self, f: impl FnOnce(i64, i64) -> i64) -> anyhow::Result<()> {
        let (b, a) = (self.pop_val()?, self.pop_val()?); // Pop two values
        self.stack.push(Value::Integer(f(a, b)));       // Push the result
        Ok(())
    }

    // Performs a checked binary operation, ensuring a condition is met before execution.
    fn checked_op(
        &mut self,
        cond: impl Fn(i64, i64) -> bool,
        f: impl Fn(i64, i64) -> i64,
        err_msg: &str,
    ) -> anyhow::Result<()> {
        let (b, a) = (self.pop_val()?, self.pop_val()?); // Pop two values
        if cond(a, b) {
            self.stack.push(Value::Integer(f(a, b))); // Push the result if the condition is met
            Ok(())
        } else {
            Err(InterpreterError::Custom(err_msg.into()).into()) // Return an error otherwise
        }
    }

    // Pops a value from the stack and returns it as an integer.
    fn pop_val(&mut self) -> anyhow::Result<i64> {
        self.stack
            .pop()
            .and_then(|v| v.as_integer().ok())
            .ok_or(InterpreterError::StackEmpty.into())
    }
}

// --- Bytecode Encoding/Decoding ---

const INSTR_SIZE: usize = 8; // Size of each instruction in bytes

// Decodes a vector of bytes into a vector of instructions.
pub fn decode_instructions(bytes: Vec<u8>) -> anyhow::Result<Vec<Instr>> {
    (bytes.len() % INSTR_SIZE == 0)
        .then(|| {
            (0..bytes.len() / INSTR_SIZE)
                .map(|i| {
                    Instr::from_u64(u64::from_be_bytes(
                        bytes[i * INSTR_SIZE..][..8].try_into().unwrap(),
                    ))
                })
                .collect()
        })
        .ok_or(InterpreterError::InvalidNumberOfBytes(bytes.len()).into())
}

// Encodes a vector of instructions into a vector of bytes.
pub fn encode_instructions(bytecode: &[Instr]) -> anyhow::Result<Vec<u8>> {
    Ok(bytecode
        .iter()
        .flat_map(|i| i.to_u64().to_be_bytes())
        .collect())
}

Instr file

The Instr struct represents a single instruction in the VM. It combines Operation (Op):(e.g., push a value, add two numbers)and value (u64) like a number to push onto the stack.

use crate::op::Op;

#[derive(Debug)]
pub struct Instr {
    pub op: Op,
    pub value: u64,
}

impl Instr {
    /// Converts an `Instr` into a `u64` by placing the opcode in the highest 8 bits and the value in the remaining 56 bits.
    pub fn to_u64(&self) -> u64 {
        ((self.op.to_u64() & 0xFF) << 56) | self.value
    }

    /// Constructs an `Instr` from a `u64` by extracting the opcode and value.
    /// 
    /// # Panics
    /// Panics if the opcode is invalid.
    pub fn from_u64(value: u64) -> Self {
        let op = Op::from_u64((value >> 56) & 0xFF).expect("Invalid Op code");
        let val = value & 0x00FF_FFFF_FFFF_FFFF;
        Instr { op, value: val }
    }
}

By packing op and value into a single 64-bit integer, you:

Reduce memory usage.
Simplify bytecode storage and transmission.
Human-Readable Debugging

To add new operations, simply update the Op enum and the VM automatically supports encoding/decoding them.

Conclusion

In this part of the series, you’ve built the foundation of our interpreter by implementing key components like the Stack, Value, and Virtual Machine. You’ve also explored how instructions are encoded and decoded, ensuring efficient execution and memory usage.

By packing operations and values into a single 64-bit integer, you’ve optimized storage and simplified debugging. This sets the stage for adding more advanced features and operations in future installments.

Building a Compiler & Interpreter in Rust! Part 2 Compiler.rs file

Pluri45 — Sat, 01 Feb 2025 23:02:28 +0000

Catch up with the first part here here.

The purpose of the compiler is to convert a string of commands (content) into tokens, then compile those tokens into instructions which will be executed on a virtual machine with vm.exceute(). The process consists of two main stages: tokenization and compilation. The tokenize function breaks the input into manageable pieces, while compile_to_instrs processes these pieces into something executable.This system is a form of parsing-turning raw data into a structured form that can be understood and executed by the machine.

Difference between compilers and interpreters:

A compiler translates the entire source code of a high-level programming language into machine code in one go. Thereafter, the system stores and executes the machine code. This approach is efficient for execution, as the translation happens before the program runs. Examples of compiled languages include C, C++, and Rust.

Meanwhile, interpreters translate high-level code into machine code line by line, executing each instruction immediately after translation. This allows for dynamic execution but can be slower compared to compiled code. Examples of interpreted languages include: Python, JavaScript, PHP, etc.

Tokenization

The tokenize function takes in a string of instructions (e.g., push 5, add). It processes the string line by line, splitting the content into individual words (tokens). If a token is a valid :

Operation (e.g., push, add, etc.)- it’s converted into an Op (Operation) enum.
Number- it’s treated as a value (integer) and converted into a Token::Value(i64).
Label (e.g., :start)- If the token starts with a colon (:).
Unknown-If the token is not recognized, it's labeled as Token::Unknown.

Tokenization Flow

The final output is a list of tokens representing the instructions. To write the Tokenization code, you’d make use of the Op file:

Op file

The Op enum defines a set of operations that form the building blocks of the virtual machine's instruction set. Each operation has a corresponding numeric value (u8), specified using the #[repr(u8)] attribute. The to_u64 and from_u64 methods allow serialization (conversion to bytes) and deserialization (conversion back to instructions) transitions between human-readable instructions and machine-friendly representations.

This makes the enum compact and easily convertible to and from bytecode. Using Option in from_u64 ensures invalid numeric values return None instead of causing runtime errors. The #[repr(u8)] attribute guarantees the enum variants match their numeric representation.

Example Variants:

Push: Adds a value to the stack.

Pop: Removes the top value from the stack.

Add: Pops two values, adds them, and pushes the result.

Complete code

use strum::FromRepr;

#[derive(Debug, FromRepr, Clone, Copy, PartialEq, PartialOrd)]
#[repr(u8)]
pub enum Op {
    Push = 0x01, Pop = 0x02, Print = 0x03, Add, Inc, Dec, Sub, Mul, Div, Mod, 
    Halt, Dup, Dup2, Swap, Clear, Over, Je, Jn, Jg, Jl, Jge, Jle, Jmp, Jz, Jnz,
}

impl Op {
    /// Converts an `Op` variant into a `u64`.
    pub fn to_u64(self) -> u64 {
        self as u64
    }

    /// Converts a `u64` back into an `Op` variant, if valid.
    pub fn from_u64(value: u64) -> Option<Self> {
        Op::from_repr(value as u8)
    }
}

The representation of the tokenization process in Code:


/// Tokenizes the input content into a vector of `Token` instances.
/// This function processes each line of the input, splits it into whitespace-separated tokens,
/// and maps them to their corresponding `Token` variants.
///
/// # Arguments
/// * `content` - The input string to tokenize.
///
/// # Returns
/// A `Result` containing a vector of `Token` instances if successful, or an error if an unexpected token is encountered.
pub fn tokenize(content: &str) -> Result<Vec<Token>> {
    let tokens: Vec<Token> = content
        .lines() // Split the input into lines
        .flat_map(|line| line.split_whitespace()) // Split each line into whitespace-separated tokens
        .filter(|raw_token| !raw_token.trim().is_empty()) // Filter out empty tokens
        .map(|raw_token| {
            // Map each raw token to its corresponding `Token` variant
            match raw_token {
                // Match keywords to their corresponding `Op` variants
                "push" => Token::Op(Op::Push),
                "pop" => Token::Op(Op::Pop),
                "print" => Token::Op(Op::Print),
                "add" => Token::Op(Op::Add),
                "inc" => Token::Op(Op::Inc),
                "dec" => Token::Op(Op::Dec),
                "sub" => Token::Op(Op::Sub),
                "mul" => Token::Op(Op::Mul),
                "div" => Token::Op(Op::Div),
                "mod" => Token::Op(Op::Mod),
                "halt" => Token::Op(Op::Halt),
                "dup" => Token::Op(Op::Dup),
                "swap" => Token::Op(Op::Swap),
                "clear" => Token::Op(Op::Clear),
                "over" => Token::Op(Op::Over),
                "je" => Token::Op(Op::Je),
                "jn" => Token::Op(Op::Jn),
                "jg" => Token::Op(Op::Jg),
                "jl" => Token::Op(Op::Jl),
                "jge" => Token::Op(Op::Jge),
                "jle" => Token::Op(Op::Jle),
                "jmp" => Token::Op(Op::Jmp),
                "jz" => Token::Op(Op::Jz),
                "jnz" => Token::Op(Op::Jnz),
                // Handle numeric values, labels, and unknown tokens
                val => {
                    if let Ok(int) = val.parse::<i64>() {
                        // If the token is a valid integer, map it to `Token::Value`
                        Token::Value(int)
                    } else if val.starts_with(':') {
                        // If the token starts with ':', treat it as a label
                        Token::Label(val.strip_prefix(':').unwrap().to_string())
                    } else {
                        // Otherwise, treat it as an unknown token
                        Token::Unknown(val.to_string())
                    }
                }
            }
        })
        .collect(); // Collect the tokens into a vector

    // Check for any unknown tokens and return an error if found
    if let Some(Token::Unknown(val)) = tokens.iter().find(|t| matches!(t, Token::Unknown(_))) {
        return Err(anyhow!("Unexpected token: '{}'", val));
    }

    // Return the successfully tokenized vector
    Ok(tokens)
}

The compile_to_instrs Function

Once the content has been tokenized, it’s ready for compilation into instructions. This function takes the tokens and processes them to generate machine-readable instructions (Instr).

/// Compiles a sequence of tokens into a vector of `Instr` (instructions).
/// Handles labels, operations, and values, and resolves label references to their addresses.
fn compile_to_instrs(tokens: &[Token]) -> Result<Vec<Instr>> {
    let mut abstract_instrs: Vec<AbstractInstr> = Vec::new(); // Stores intermediate abstract instructions
    let mut labels: HashMap<String, usize> = HashMap::new();  // Maps label names to instruction indices
    let mut tail = tokens; // Tracks the remaining tokens to process

    // Process tokens into abstract instructions
    while !tail.is_empty() {
        match tail {
            // Handle label definitions
            [Token::Label(name), rest @ ..] => {
                // Ensure the label is not defined more than once
                if labels.contains_key(name) {
                    return Err(anyhow!("Label '{}' defined more than once", name));
                }
                // Map the label to the current instruction index
                labels.insert(name.clone(), abstract_instrs.len());
                tail = rest; // Move to the next tokens
            }

            // Handle operations without values (e.g., Pop, Add, etc.)
            [Token::Op(op), rest @ ..] if *op < Op::Push => {
                abstract_instrs.push(AbstractInstr {
                    op: *op,
                    value: AbstractValue::None, // No value associated with this operation
                });
                tail = rest; // Move to the next tokens
            }

            // Handle operations with integer values (e.g., Push)
            [Token::Op(op), Token::Value(value), rest @ ..] if *op >= Op::Push => {
                abstract_instrs.push(AbstractInstr {
                    op: *op,
                    value: AbstractValue::Integer(*value), // Associate the integer value
                });
                tail = rest; // Move to the next tokens
            }

            // Handle operations with label references (e.g., Jmp, Je, etc.)
            [Token::Op(op), Token::Label(label), rest @ ..] if *op > Op::Push => {
                abstract_instrs.push(AbstractInstr {
                    op: *op,
                    value: AbstractValue::Label(label.clone()), // Associate the label
                });
                tail = rest; // Move to the next tokens
            }

            // Handle invalid token sequences
            _ => return Err(anyhow!("Invalid token sequence in compilation: {:?}", tail)),
        }
    }

    // Resolve label references to their corresponding instruction addresses
    for instr in &mut abstract_instrs {
        if let AbstractInstr {
            value: AbstractValue::Label(label),
            ..
        } = instr
        {
            // Look up the label's address in the `labels` map
            if let Some(&addr) = labels.get(label) {
                instr.value = AbstractValue::Integer(addr as i64); // Replace label with address
            } else {
                return Err(anyhow!("Label '{}' not defined", label)); // Error if label is undefined
            }
        }
    }

    // Convert abstract instructions into concrete `Instr` objects
    let instrs = abstract_instrs
        .into_iter()
        .map(|abstract_instr| Instr {
            op: abstract_instr.op,
            value: match abstract_instr.value {
                AbstractValue::Integer(value) => value as u64, // Convert integer to u64
                AbstractValue::None => 0,                     // Default value for operations without values
                AbstractValue::Label(_) => unreachable!(),     // Labels should already be resolved
            },
        })
        .collect(); // Collect into a vector of `Instr`

    Ok(instrs) // Return the compiled instructions
}

The input is a vector of Token enums. The function creates an empty list of AbstractInstr to hold the intermediate instructions. The HashMap<String, usize> called labels to map labels to their positions in the instruction list, then Iterates over the tokens:

If it encounters a label (Token::Label), it adds it to the labels map and continues.

If it encounters an operation (Token::Op), it processes it by checking the associated value type (whether it's just an operation like push or includes additional data, like a number or label). "push" becomes Token::Op(Op::Push)."42" becomes Token::Value(42).

":start" becomes Token::Label("start") . If the sequence of tokens doesn’t match an expected pattern (like an invalid token sequence), it returns an error.

The compile Function

The compile function is a high-level function that combines tokenize and compile_to_instrs. It tokenizes the input and then compiles the tokens into instructions. It prints the tokens and instructions for debugging purposes.

/// Compiles the provided content into a vector of instructions (`Instr`).
///
/// This function performs the following steps:
/// 1. Tokenizes the input content into a sequence of tokens.
/// 2. Compiles the tokens into a sequence of instructions.
/// 3. Returns the compiled instructions or an error if any step fails.
///
/// # Arguments
/// * `content` - The input string to compile.
///
/// # Returns
/// - `Ok(Vec<Instr>)` - A vector of instructions if compilation succeeds.
/// - `Err(MyError)` - An error if tokenization or compilation fails.
pub fn compile(content: &str) -> Result<Vec<Instr>, MyError> {
    // Step 1: Tokenize the input content into tokens.
    let tokens = tokenize(content)?;
    println!("Tokens: {:#?}", tokens); // Debug print the tokens for inspection.

    // Step 2: Compile the tokens into a sequence of instructions.
    let instrs = compile_to_instrs(&tokens)?;
    println!("Instructions: {:#?}", instrs); // Debug print the instructions for inspection.

    // Step 3: Return the compiled instructions.
    Ok(instrs)
}

Here’s the flow:

The input is a string of content containing instructions. It calls tokenize to get the tokens and then compile_to_instrs to convert them into instructions and finally returns a vector of compiled instructions (Instr).

Conclusion.

The compiler transforms human-readable instructions into machine-executable code through tokenization and compilation. The tokenize function breaks input into tokens (e.g., operations, values, labels), while compile_to_instrs converts these tokens into instructions for the virtual machine. The Op enum, with its compact numeric representation (u8), ensures efficient execution and serialization. Error handling via Option and Result ensures robustness. Together, these components create a reliable system for parsing, compiling, and executing programs on a virtual machine.

Building a Compiler & Interpreter in Rust. Part 1

Pluri45 — Sun, 19 Jan 2025 11:30:56 +0000

Computers do not understand human languages directly, as they operate in binary machine code. To bridge this gap, intermediaries like compilers and interpreters convert human-readable code into machine-readable instructions. High-level and low-level programming languages were invented to simplify the process of giving instructions to computers in a way that humans can more easily understand and write.

Difference between compilers and interpreters:

Building a compiler for an MCL language in Rust-general file structure and function.

MCL is an invented language, you can decide to build yours if you feel excited. The objective would be to take the high level code from the .mcl file, using the code in the compiler file. The compiler reads the keywords that match the already started instructions, then converts the file to bytecode(an intermediary language ). The interpreter has a Virtual Machine that is called to execute the bytecode into machine code, and the output back into human readable language is outputted in the terminal.

Main file &General overview.

Compiling and executing:

The compiler processes the .mcl file, converting it into an intermediate representation ( the bytecode). You need to take instructions from the terminal. First, you need to import modules. This program provides a framework for compiling, executing, and handling bytecode. By breaking down the code, you will see how each function contributes to processing the .mcl file.

Imports and Modules

The first part of the code imports the important libraries and modules:

// clap::Parser: Used for command-line argument parsing.
use clap::Parser;

// anyhow::Result: Simplifies error handling.
use anyhow::Result;

// log library: Provides logging functionality for different levels (e.g., info, debug, error).
use log::{debug, info, error};

// std utilities for file manipulation, path management, exiting the program, and writing to files.
use std::fs;
use std::path;
use std::process::exit;
use std::io::Write;

// Modules (compilers, interpreter, op, instr) define core functionality 
// for the virtual machine, compilation, and bytecode handling.
// These are in separate files and are imported as modules into main.rs.
mod compilers;
mod interpreter;
mod op;
mod instr;

// Specific imports from the modules.
use crate::instr::Instr;
use crate::interpreter::{VM, decode_instructions, encode_instructions};

Argument Parsing with clap

The Args structure defines command-line arguments:

#[derive(Parser)]
struct Args {
#[arg(long, default_value_t = false)]
//--compile: Compiles source files.
compile: bool,
#[arg(long, default_value_t = false)]
//--exec: Executes bytecode.
exec: bool,
#[arg(long, default_value_t = false)]
//--optimize: Enables optimization (placeholder, unused here).
optimize: bool,
#[arg(long, default_value_t = false)]
// --decompile: For decompiling bytecode (placeholder, unused here).
decompile: bool,
#[arg(long)]
// --file: Specifies the file to process.
file: Option<String>,

}

The Main Function

The main function initializes the program and handles errors:

fn main() {
    // Attempt to run the main logic of the program
    if let Err(err) = run() {
        // If an error occurs, log the error message and exit with a non-zero status code
        error!("Error: {}", err);
        exit(1);
    }
}

Logging Setup

You write the logger to format errors properly in the terminal. This ensures proper spacing and colours are added to the terminal when it’s logged.


env_logger::builder()
    .filter_level(log::LevelFilter::max())
    .format(|buf, record| {
        let level = match record.level() {
            log::Level::Error => "\x1b[31mERROR\x1b[0m", // Red
            log::Level::Warn => "\x1b[33mWARN\x1b[0m",   // Yellow
            log::Level::Info => "\x1b[32mINFO\x1b[0m",   // Green
            log::Level::Debug => "\x1b[34mDEBUG\x1b[0m", // Blue
            log::Level::Trace => "\x1b[35mTRACE\x1b[0m", // Magenta
        };

        writeln!(buf, "{:14} | {}", level, record.args())
    })
    .init();

Core Logic

a. Compile

This section compiles the input file into bytecode if the --compile flag is set:

let args = Args::parse();

let mut bytecode = vec![];

// Compile
let args = Args::parse(); // Parse command-line arguments
let mut bytecode = vec![]; // Initialize an empty vector to store the compiled bytecode

// Compile the source file if the --compile flag is provided
if args.compile {
    // Check if a file is specified
    if let Some(filename) = args.file.as_deref() {
        // Verify that the file has the correct extension (.mcl)
        if path::Path::new(&filename).extension() == Some(std::ffi::OsStr::new("mcl")) {
            // Read the file, compile it, and convert instructions to u64
            bytecode = compilers::compile(&fs::read_to_string(filename)?)
                .into_iter()
                .map(|instr| instr.to_u64())
                .collect();
        } else {
            // Print an error if the file extension is unsupported
            eprintln!("Error: Unsupported file extension for compilation.");
            exit(1); // Exit with an error code
        }
    } else {
        // Print an error if no file is specified
        error!("Error: --file must be specified when using --compile");
        exit(1); // Exit with an error code
    }
}

This is where you take the inputs from the compilers file which you will come about in the next section. It takes raw inputs from the file and converts them into tokens that can be processed by the interpreter. It does this by checking if the input file is an .mcl file. It reads and compiles the file into bytecode using the compilers::compile function.

Execute

If --exec is specified, the program executes the bytecode:


// Execute the program if the `exec` flag is set
if args.exec {
    // Check if the `compile` flag is not set
    if !args.compile {
        // Check if a file is specified
        if let Some(file) = args.file.as_deref() {
            // Verify that the file has the correct extension (.mcl)
            if path::Path::new(file).extension() == Some(std::ffi::OsStr::new("mcl")) {
                // Print an error message and exit if the file is not compiled
                error!("Error: Cannot execute an uncompiled file.");
                exit(1);
            }

            // Read the file and convert its contents into bytecode
            bytecode = fs::read(file)?
                .into_iter()
                .map(|instr| instr.to_u64())
                .collect();
        } else {
            // Print an error message and exit if no file is specified
            eprintln!("Error: --file must be specified.");
            exit(1);
        }
    }

    // Create a new virtual machine (VM) instance
    let mut vm = VM::new();

    // Execute the bytecode using the VM
    vm.execute(bytecode)?;
}

It reads the compiled bytecode and executes it in a virtual machine (VM) using the vm.execute method.

Save Bytecode

If execution is not required, the bytecode is saved to a file:

else {
    // Save bytecode to a file
    if let Some(file) = args.file.as_deref() {
        // Convert bytecode into a vector of instructions
        let instrs: Vec<Instr> = bytecode.iter().map(|&b| Instr::from_u64(b)).collect();

        // Create a new file with the specified name and .mclb extension
        let mut new_file = fs::File::create(path::Path::new(file).with_extension("mclb"))?;

        // Write the encoded instructions to the file
        new_file.write_all(encode_instructions(&instrs)?.as_slice())?;
    } else {
        // Handle the case where the --file argument is not provided
        error!("Error: --file must be specified for output.");
        exit(1); // Exit the program with an error code
    }
}

// Return Ok(()) to indicate successful execution
Ok(())

The interpreter converts the bytecode back into instructions and saves it to a .mclb file, which is its output.

Conclusion.

In this article, you learned about the components of building a compiler and interpreter in Rust. You now know the difference between compiled and interpreted languages. Lastly, the general architecture of the compiler project which primarily consists of modules such as : Compilers, Interpreter, op, and instr. You will learn about the modules in future releases of the series.

If you are interested in the video verison of this article, check out

Starting Vuejs as a beginner: Top 5 concepts you need to know.

Pluri45 — Wed, 21 Aug 2024 21:42:36 +0000

Introduction

Vuejs has been a top choice for developers for reasons that it is simple, lightweight , and easy to learn when compared to other libraries . Its files are organized as Single File Components (SFCs) that include template, script, and style sections. Vuejs is built to be flexible and capable of helping you build and scale your projects. In this article, you will learn some of the concepts you will come across while building with Vue.js.

Concepts

Options and Composition Api
APP.vue
On Mounted
View Models
Router & Router-view

1. Options and Composition API

The Options and Composition API are different approaches to how you structure the logic of your Vuejs code. As the name implies, Options API organizes the logic of your code options. When you want to define new methods, you simply add it to the structure of the code, providing a new method (option) to be used in your code. The sample code below provides an example:

export default {

data() {

return {

name: 'john',

status: "pending",

tasks: ['Task one', 'Task Two', 'Task Three'],

link: 'https://google.com'

};

},

methods: {

toggleStatus() {

if (this.status === 'active') {

this.status = 'pending';

} else if (this.status === 'pending') {

this.status = 'inactive';

} else {

this.status = 'active';

}

}

}

};

In the options API, the reactive state is defined by data(You can name it whatever you want but keep it consistent ). The method returns an object, all these are within the export default component. By Exporting a component, you can make use of the method anywhere it is imported in your coding environment.

If you wanted to write the code above as a composition api, you will do the following:


<script lang="ts" setup>

import { ref } from "vue";

import { RouterLink } from "vue-router";

import BounceLoader from 'vue-spinner/src/BounceLoader.vue';

import SingleNowPlaying from './singleNowPlaying.vue';



// Reactive state variables

const name = ref('john');

const status = ref('pending');

const tasks = ref(['Task one', 'Task Two', 'Task Three']);

const link = ref('https://google.com');



// Method for toggling status

const toggleStatus = () => {

if (status.value === 'active') {
status.value = 'pending';
} else if (status.value === 'pending') {

status.value = 'inactive';
} else {

status.value = 'active';
}
};

</script>

The Composition API was written to appeal to React developers who want to use Vue. When you compare the Options API code to composition API, you will observe that the setup was defined along with the script.When you import the methods/ components you want to use, you can directly define your functions in your code without exporting them.

2. Router & Router-view

The Router comes with installing the Vue Router Package and it helps you manage routes in your application. Here, your components are connected to URLs that will be displayed when visited on the browser.The Router-view serves as a portal to render the component of an initiated route. The following code sample shows how the Router works.

import { createRouter, createWebHistory } from 'vue-router'
import homeview from '../views/homeview.vue'



const router = createRouter({
  history: createWebHistory('/Movie-database/'),
  routes: [
    {
      path: '/',
      name: 'home',
      component: homeview 
    }
  ]
})

export default router;

From the code above, you import the component or view files you want to connect to a URL. The path is the address that shows up in your browser, the name is a class that helps you target a specific component outside your route folder.

3. On Mounted.

OnMounted is a lifecycle hook that monitors when a component is ready for use(mounted). You will typically make use of the onMounted hook for Fetching data from an API.

onMounted(async () => {
try {
const response = await axiosClient.get('/movie/now_playing');
movies.value = response.data.results;
console.log(movies.value);
} catch (error) {
console.error('Error fetching movies:', error);
} finally {

isLoading.value = false;

}

});

4. View Models(V-model)

V-model create a two-way binding between a form input element like and a data property in your component. This means that when the user changes the value of the input, the data property is updated instantly, and when the data property changes, the input's value is updated as well. Just like the code below:


<div class="mb-4">

<label class="block text-gray-700 font-bold mb-2"> Location </label>

<input

type="text"

id="location"

v-model="location"

name="location"

class="border rounded w-full py-2 px-3 mb-2"

placeholder="Company Location"

required

/>

</div>



<script>

import { ref } from 'vue';

export default {

setup() {

const location= ref('');

return {

location

};

}

}

</script>

5. App.vue

The App.vue file loads and displays all the files in your application to the user. You can state the Navbar component and use to load up the rest of the files in your application.

<script setup lang="ts">
import {RouterView} from 'vue-router';
import Navbar from './components/navbar.vue';

</script>

<template>
    <div>
        <Navbar/>
        <RouterView/>
    </div>
</template>

Conclusion.

In this article, you learned about the fundamental principles of building with Vue.js, the Options and composition APIs being one of the most important amongst them. For more information about the vuejs framework, you can check out the official documentation here: documentation .

Building an Equal weight portfolio allocation strategy with Python

Pluri45 — Tue, 23 Jul 2024 19:49:01 +0000

Introduction

This article focuses on building an equal-weight portfolio allocation strategy with Python. If you had $10,000 that you’d like to invest in the fifty top-performing companies in the S&P 500 index, how would you allocate capital across these stocks? In this article, you will learn how to extract value from the top S&P 500 companies by tabulating the Ticker, current trading price, 1-year % return, and calculating the number of shares to buy on the top 50 performing stocks.

Creating a new Jupyter Notebook.

Google Colab is a cloud-based Jupyter notebook that allows you to write and execute python code on the web.

Importing relevant Tickers and libraries.

Follow this link to download the S&P500 ticker symbols. This will make it easy for you to extract the data associated with each ticker.

Installing Yahoo Finance and importing libraries.

Use the following codes to import Yahoo-Finance data.

!pip install "yfinance".

When you are done, import the following libraries.

import pandas as pd

import numpy as np

import os

from datetime import datetime, timedelta

Pandas- present your data as dataframes and series, allowing you to clean, manipulate, and analyze data with in-built functionalities. Numpy is a library used for working with arrays and general mathematical functions. Importing os helps you manipulate file paths that will used further in the project. Finally, the Datetime class helps you work with dates and times and helps us manipulate dates and times in general. Timedelta, as the name implies, is used to find a duration within a time period, beginning and end.

Extracting the 1 year, 6 month, 3 month, and Monthly return on each stock in the s&p500 index.

These periods will help you extract the returns of each stock within each time frame. Comments are added to each chunk of code to explain what is happening.


import os
import pandas as pd
import yfinance as yf
from datetime import datetime

def get_first_last_trading_days(stocks_file, years):
    """
    Retrieves and calculates the first and last trading days for a list of stocks over specified years.
    Saves the results to CSV files and returns a dictionary containing the data.

    Args:
        stocks_file (str): Path to the CSV file containing stock tickers.
        years (list): List of years to process.

    Returns:
        dict: A dictionary containing the calculated ratings for each stock.
    """
    # Initialize an empty dictionary to store data
    data = {}

    # Read the stock tickers from the CSV file
    stocks = pd.read_csv(stocks_file)['Ticker'].tolist()

    # Create a directory to store the stock data if it doesn't exist
    if not os.path.exists('stockss_dfs'):
        os.makedirs('stockss_dfs')

    def rating(df, startdate, enddate, freq):
        """
        Calculates the percentage change in stock prices over a specified frequency.

        Args:
            df (pd.DataFrame): Stock data.
            startdate (str): Start date for the analysis.
            enddate (str): End date for the analysis.
            freq (str): Frequency for grouping data ('Y', 'M', '3M', '6M').

        Returns:
            pd.Series: Percentage change in stock prices.
        """
        # Define offset based on time frequency
        if freq == 'Y':
            offset = '366 days'
        elif freq == 'M':
            offset = '31 days'
        elif freq == '3M':
            offset = '93 days'
        elif freq == '6M':
            offset = '183 days'
        else:
            raise ValueError("Frequency not supported. Use 'Y', 'M', '3M', or '6M'.")

        # Filter the dataframe and calculate the % change ratio
        dff = df.loc[(df.index >= pd.Timestamp(startdate) - pd.Timedelta(offset)) & (df.index <= pd.Timestamp(enddate))]
        dfy = dff.groupby(pd.Grouper(level='Date', freq=freq)).tail(1)
        ratio = (dfy['Close'] / dfy['Close'].shift() - 1) * 100

        return ratio

    # Loop through each year
    for year in years:
        # Define start and end dates for the year
        start_date = f"{year}-01-01"
        end_date = f"{year}-12-31"

        # Loop through each stock ticker
        for stock in stocks:
            # Define the file path to save/load the stock data
            file_path = f'stockss_dfs/{stock}_{year}.csv'

            # Check if the file already exists
            if not os.path.exists(file_path):
                try:
                    # Download the stock data using yfinance
                    df = yf.download(stock, start=start_date, end=end_date)
                    df.index = pd.to_datetime(df.index)
                    df.index = df.index.tz_localize(None)

                    # Proceed if the dataframe is not empty
                    if not df.empty:
                        # Calculate ratings for different frequencies
                        period_rating = rating(df, start_date, end_date, freq='Y')
                        period_rating_monthly = rating(df, start_date, end_date, freq='M')
                        period_rating_3months = rating(df, start_date, end_date, freq='3M')
                        period_rating_6months = rating(df, start_date, end_date, freq='6M')

                        # Store the ratings in the data dictionary
                        data[stock] = {
                            'Yearly': period_rating,
                            'Monthly': period_rating_monthly,
                            '3 Months': period_rating_3months,
                            '6 Months': period_rating_6months
                        }

                        # Save the results to a CSV file
                        df_results = pd.DataFrame({
                            'Yearly': period_rating,
                            'Monthly': period_rating_monthly,
                            '3 Months': period_rating_3months,
                            '6 Months': period_rating_6months
                        })

                        df_results.to_csv(file_path, index=True)

                except Exception as e:
                    # Handle any errors that occur during processing
                    print(f"Error processing {stock} for year {year}: {e}")
                    continue

    return data


# Get the current year and the previous year
current_year = datetime.now().year
years = [current_year - i for i in range(1, 2)]

# Retrieve the data
stocks_file = '/content/sp_500_stocks.csv'
data = get_first_last_trading_days(stocks_file, years)

When you run the code, you will get the following:

In the image above, you will observe that the 1-year column is empty. This is because we need the difference at the end of two years to get the return on a year. Alternatively, we can creatively add up the values of individual months for a 12 month cycle, and we trust that will give us the result of the 1 year result. The following code does just that for us.


import os
import pandas as pd
import yfinance as yf

def extract_sum_of_1_year_return(directory):
    """
    Extracts the sum of the 'Monthly' column from each CSV file in the given directory.
    Also extracts the ticker name from the file name.

    Args:
        directory (str): Path to the directory containing CSV files.

    Returns:
        list: A list of dictionaries containing the ticker name and the yearly sum.
    """
    all_instruments = []

    # List all the files in the directory
    files = os.listdir(directory)

    # Iterate over the files
    for file in files:
        file_path = os.path.join(directory, file)

        # Check if the path is a file (not a directory)
        if os.path.isfile(file_path):
            # Read the CSV file into a DataFrame
            df = pd.read_csv(file_path)

            # Calculate the sum of the 'Monthly' column
            df_sum = df['Monthly'].sum()

            # Extract the ticker name from the file name
            file_full_path = file_path.split('/')
            real_file_path = file_full_path[3].split('_')
            ticker_name = real_file_path[0]

            # Append the ticker name and yearly sum to the list
            all_instruments.append({
                "ticker": ticker_name,
                "yearly_sum": df_sum
            })

    return all_instruments


# Directory containing the CSV files
directory = "/content/stockss_dfs"

# Call the function to extract yearly sums and ticker names
results = extract_sum_of_1_year_return(directory)


def get_stocks(results):
    """
    Fetches the current price for each stock ticker using Yahoo Finance API.
    Only includes stocks where the current price is successfully retrieved.

    Args:
        results (list): List of dictionaries containing ticker names and yearly sums.

    Returns:
        list: A list of dictionaries containing ticker names, current prices, and yearly sums.
    """
    # Initialize a list to hold the stock data that was successfully processed
    successful_stocks = []

    # Loop through the results
    for stock in results:
        try:
            # Fetch stock information using Yahoo Finance API
            api_url = yf.Ticker(stock['ticker'])
            stock_instrument = api_url.info

            # Get the current price of the stock
            current_price = stock_instrument.get('currentPrice', None)

            # Only add to successful_stocks if the current price is not None
            if current_price is not None:
                successful_stocks.append({
                    'ticker': stock['ticker'],
                    'current_price': current_price,
                    'yearly_sum': stock['yearly_sum']
                })
        except Exception as e:
            # Skip the stock if an error occurs (e.g., invalid ticker or API issue)
            continue

    return successful_stocks


# Call the function to get stock data with current prices
final_stocks = get_stocks(results)

Output :

Selecting the top 50 performing stocks.

You will calculate the number of shares per stock you can buy with a certain amount in capital. First you have to select the first 50 stocks with the highest return within a one-year time frame.


# Ensure the 'yearly_sum' column is numeric
# Convert the 'yearly_sum' column to numeric, coercing any non-numeric values to NaN
final_stocks_df['yearly_sum'] = pd.to_numeric(final_stocks_df['yearly_sum'], errors='coerce')

# Drop rows with NaN values in the 'yearly_sum' column
# This removes any rows where the 'yearly_sum' value could not be converted to a number
final_stocks_df.dropna(subset=['yearly_sum'], inplace=True)

# Sort the dataframe by the 'yearly_sum' column in descending order
# This arranges the rows from highest to lowest based on the 'yearly_sum' values
final_stocks_df.sort_values('yearly_sum', ascending=False, inplace=True)

# Select the top 50 rows
# Keep only the first 50 rows after sorting
final_stocks_df = final_stocks_df[:50]

# Drop the 'level_0' column
# Remove the 'level_0' column as it is no longer needed
final_stocks_df.drop(columns=['level_0'], inplace=True)

# Display the dataframe
# Show the final processed dataframe
final_stocks_df

Output :

Calculating portfolio amount

Here, you choose an initial starting balance for your portfolio, this amount will be split in equal weights across all the stocks.


def portfolio_input():
    """
    Prompts the user to enter the value of their portfolio.
    Validates the input to ensure it is a number.
    """
    global portfolio_size  # Declare portfolio_size as a global variable

    # Prompt the user to enter the portfolio value
    portfolio_size = input('Enter the value of your portfolio: ')

    try:
        # Try to convert the input to a float
        val = float(portfolio_size)
    except ValueError:
        # Handle the case where the input is not a number
        print("That's not a number! \nPlease try again:")
        # Prompt the user again for the portfolio value
        portfolio_size = input('Enter the value of your portfolio: ')
        val = float(portfolio_size)  # Convert the new input to a float

# Call the portfolio_input function
portfolio_input()

# Print the portfolio size entered by the user
print(portfolio_size)

Output:

Calculating the number of shares to buy

Divide the portfolio size by the total number of stocks in the s&p500 index to get average amount of investable capital, then calculate the number of shares to buy by dividing the value you got by the current price the stock is trading at.


# Find the mean of the portfolio size.
position_size = float(portfolio_size) / len(final_stocks_df.index)


# Insert the result of 'Enterprise value' / 'Stock Price' into the column of 'Number of Shares to Buy'.

final_stocks_df['Number of Shares to Buy'] = np.floor(position_size / final_stocks_df['current_price']).astype(int)

final_stocks_df

Output:

Conclusion.

In this article, you learned how to allocate capital among the top 50 performing stocks in the S&P 500. You cleaned the data to drop NAN(not a number) data that would have messed with results. This article was inspired by freecode camp’s tutorial freecodecamp, but since much original thought went into writing the code, I decided to write and publish. I hope you learned a thing or two, see you next time.

Building a Telegram Bot that delivers weekly stock opening and closing prices.

Pluri45 — Mon, 24 Jun 2024 10:36:46 +0000

With Telegram, you can create a bot that helps you with different tasks such as giving you sports updates, coordinating how you receive membership payments in private groups, welcoming users to a group and removing spammers, etc. In this tutorial, you will learn how to create a telegram bot that retrieves the opening and closing prices of different stocks with python.

Introduction

What are telegram bots?

Telegram bots are programmes that act as chat agents while performing sets of predefined instructions based on user inputs. There are various kinds of bots, each having different levels of complexity. For example, do you know that you can start a zoom meeting on telegram through their bot?

Setting up your bot.

Searching for BotFather on telegram

You need to contact BotFather on telegram to create your unique bot. BotFather can be described as the command center that manages other bots. All you have to do is open your telegram app and look up BotFather from the search bar.

Creating your Telegram Bot

Click on the /newbot option to create a new bot.

Supplying your Bot’s name and username.

You will be provided an option to insert your bot’s name, thereafter, its username.

Getting your API keys

When you are done, Telegram will supply you with API keys.

Installing Telegram Bot and Yahoo Finance python SDK

You need to install the python Telegram-bot wrapper. The wrapper is a library that provides an asynchronous interface for the Telegram Bot API. You will also need to install yfinance, which offers a threaded and Pythonic way to download market data from YahooFinance

Open up your code editor and in your terminal and type:

$ pip install python-telegram-bot --upgrade

$ pip install yfinance --upgrade --no-cache-dir

Writing scripts to receive messages sent to the bot.

Here, you are going to import functions that would help us interpret the message sent to the bot. There’s also a slight modification in how the bot would work. When the user clicks on a start command, the bot would send a response containing the user’s name. The bot would expect a final input from the user, before completing the operation. This operation is represented in the image below.

from  telegram.ext import ApplicationBuilder, ContextTypes, CommandHandler, MessageHandler, filters

from telegram import Update

import logging

import yfinance as yf

from telegram import ForceReply, Update



#Defining bot Token & username

TOKEN = 'Insert your telegram Token'

BOT_USERNAME= '@Stock_Instruments_Bot'



logging.basicConfig(

format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',

level=logging.INFO

)
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:

user = update.effective_user

await update.message.reply_html(

rf"Hi {user.mention_html()}! I am your Stock bot. Input your stock name/ticker (check Yahoo Finance for ideas), and I will give you the opening and closing prices for the past 5 days.",

reply_markup=ForceReply(selective=True),

)

Testing the bot connection.

You will create a command handler that you have already registered with the bot and test. Each time you create a new async function or command, you would add it under the most recent command. The application.run_polling()code shows if the bot is working at the terminal.

if __name__ == '__main__':

application = ApplicationBuilder().token(TOKEN).build()

start_handler = CommandHandler('start', start)

application.run_polling()

Retrieving opening and closing prices

The code below is written to retrieve the opening and closing for the past five days of any instrument the user inputs.


async def instrumentprice(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:

instrument_data_frombot = update.message.text

ticker_data = yf.Ticker(instrument_data_frombot)

instrument_data = ticker_data.info

try:

long_business_summary = instrument_data['longBusinessSummary']

except KeyError:

# If the instrument is not found, send an error message

await update.message.reply_text("Financial Instrument not found. Please check Yahoo Finance for the correct ticker code.")

# Construct the message with the business summary

message = f'*About*\n{long_business_summary}\n\n'

try:

hist =ticker_data.history(period="5d")

Open_Price = hist['Open']

Close_Price = hist['Close']

message += "\n*Here are the opening and closing prices for the past 5 days:\n"

for date in hist.index:

message += f"Date: {date.date()}\nOpen: {Open_Price[date]}\nClose: {Close_Price[date]}\n\n"

await update.message.reply_text(message)

except KeyError:
#If the instrument is not found, send an error message

await update.message.reply_text("Financial Instrument not found. Please check Yahoo Finance for the correct ticker code.")

Understanding the code:

You have two objectives with this function. Retrieving the business summary and the open and closing prices. You retrieve the object that contains the business summary with the instrument_data variable. You use the try/ except method in both instances of retrieving the business summary and instrument prices because there’s a chance the operation can fail so you must account for the condition for when it does. When each of the exception handling methods are completed, the results are added to the message variable, and the bot outputs the response to the user.

Handling unknown input.

When a user sends a message that the Bot is not equipped to handle, you create a function to take care of that.


async def unknown(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:

await context.bot.send_message(chat_id=update.effective_chat.id, text="Sorry, I didn't understand that command.")

Full Code

from telegram import Update
from telegram.ext import ApplicationBuilder, ContextTypes, CommandHandler, MessageHandler, filters
import logging
import yfinance as yf
from telegram import ForceReply

# Defining bot Token & username
TOKEN = 'Insert Token'
BOT_USERNAME = '@Stock_Instruments_Bot'

logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    level=logging.INFO
)

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    user = update.effective_user
    await update.message.reply_html(
        rf"Hi {user.mention_html()}! I am your Stock bot. Input your stock name/ticker (check Yahoo Finance for ideas), and I will give you the opening and closing prices for the past 5 days.",
        reply_markup=ForceReply(selective=True),
    )  

async def instrumentprice(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    instrument_data_frombot = update.message.text
    ticker_data = yf.Ticker(instrument_data_frombot)
    instrument_data = ticker_data.info
    try:
        long_business_summary = instrument_data['longBusinessSummary']
    except KeyError:
        # If the instrument is not found, send an error message
        await update.message.reply_text("Financial Instrument not found. Please check Yahoo Finance for the correct ticker code.")
        return

    # Construct the message with the business summary
    message = f'*About*\n{long_business_summary}\n\n'
    try:
        hist = ticker_data.history(period="5d")
        Open_Price = hist['Open']
        Close_Price = hist['Close']
        message += "\n*Here are the opening and closing prices for the past 5 days:\n"
        for date in hist.index:
            message += f"Date: {date.date()}\nOpen: {Open_Price[date]}\nClose: {Close_Price[date]}\n\n"
        await update.message.reply_text(message)
    except KeyError:
        # If the instrument is not found, send an error message
        await update.message.reply_text("Financial Instrument not found. Please check Yahoo Finance for the correct ticker code.")

async def unknown(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await context.bot.send_message(chat_id=update.effective_chat.id, text="Sorry, I didn't understand that command.")

if __name__ == '__main__':
    application = ApplicationBuilder().token(TOKEN).build()

    start_handler = CommandHandler('start', start)
    instrumentprice_handler = MessageHandler(filters.TEXT & ~filters.COMMAND, instrumentprice)
    unknown_handler = MessageHandler(filters.COMMAND, unknown)

    application.add_handler(start_handler)
    application.add_handler(instrumentprice_handler)
    application.add_handler(unknown_handler)

    application.run_polling()

Conclusion.

By installing the telegram and yahoo finance SDK, you built a bot that could retrieve the opening and closing prices for the previous five days. `

You saw how to create an account with BotFather and use the token generated to build a functional bot that could take instructions from users.The source code of the bot can be found on Github and if you have further questions, you can drop them in the comments.

DEV Community: Pluri45

Leverage in the Predictions Market.

What is the Prediction Market?

What is the impact of Leverage in trading?

Why has it been difficult to provide Leverage in Predictions market?

There is a clear upper limit.

The lower limit is zero.

Binary Outcomes.

Who is actively solving this problem?

Building on the Stellar Blockchain

Introduction

What is the Stellar Blockchain?

Why Stellar?

Stellar Consensus Protocol (SCP):

Stellar Use Cases

Cross-Border Payments

Tokenization

Conclusion

Building a Compiler & Interpreter in Rust! Part 3

Building a Compiler & Interpreter in Rust! Part 3

Interpreters

Value and Stack Management

Virtual Machine (VM)

Instr file

Conclusion

Building a Compiler & Interpreter in Rust! Part 2 Compiler.rs file

Difference between compilers and interpreters:

Tokenization

Tokenization Flow

Op file

Complete code

The compile_to_instrs Function

The compile Function

Conclusion.

Building a Compiler & Interpreter in Rust. Part 1

Difference between compilers and interpreters:

Building a compiler for an MCL language in Rust-general file structure and function.

Main file &General overview.

Compiling and executing:

Imports and Modules

Argument Parsing with clap

The Main Function

Logging Setup

Core Logic

Execute

Conclusion.

Top 4 Video testimonial websites for Indie-hackers in 2024(VocalVideo shines!).

Introduction

Contents

1. VocalVideo.

Collecting Videos.

Editing

Publishing to your website and social platforms

No app downloads required.

Incentives.

Branding.

Voice-only feature.

2. VideoPeel

3. Testimonial

4. Boast

Conclusion.

Starting Vuejs as a beginner: Top 5 concepts you need to know.

Introduction

Concepts

1. Options and Composition API

2. Router & Router-view

3. On Mounted.

4. View Models(V-model)

5. App.vue

Building an Equal weight portfolio allocation strategy with Python

Introduction

Creating a new Jupyter Notebook.

Importing relevant Tickers and libraries.

Installing Yahoo Finance and importing libraries.

Extracting the 1 year, 6 month, 3 month, and Monthly return on each stock in the s&p500 index.

Selecting the top 50 performing stocks.

Calculating portfolio amount

Calculating the number of shares to buy

Conclusion.

Building a Telegram Bot that delivers weekly stock opening and closing prices.