Thank you, this is very beneficial to me

I found them here: /System/Library/ExtensionKit/Extensions/. To copy the icons file, right click on the extension from this path, press "Get Info", click on the icon from the info panel, press Command+C and paste it in Figma, then save the file.

Credits: i reached out to the author of this YouTube channel https://www.youtube.com/@brycedotco and he hinted me the location.

✅ Yes — v11 introduces a rewritten PKCS#11 integration that supports selecting keys by label, and allows you to specify the certificate separately via windowsCertificatePath.

Do I still need to provide the .pem certificate in v11? ✅ Yes, unless you store the certificate with the key in a HSM that exposes both (which Cloud KMS doesn’t).

Can this be solved in Install4J v8 or v10? ❌ Unlikely, because these versions require both key + certificate to be visible in the PKCS#11 module, which libkmsp11 cannot provide.

The most upvoted answer did not work for me. Chances are that your default Apache install is PID 4 and that Apache is trying to use the already occupied port 80. Are these your symptoms? Chance are also that the default on //localhost is IIS. Is this also a symptom for you? If so, go to Control panel and disable IIS completely and reboot. Worked for me on Windows 11.

# PowerShell Script to Extract SSL Certificate from a Remote Server (LDAPS)

# Define server and port

$server = "fggg"

$port = 636

# Connect and retrieve the certificate

$tcpClient = New-Object System.Net.Sockets.TcpClient

$tcpClient.Connect($server, $port)

$sslStream = New-Object System.Net.Security.SslStream($tcpClient.GetStream(), $false, ({$true}))

$sslStream.AuthenticateAsClient($server)

# Export the certificate

$remoteCert = $sslStream.RemoteCertificate

$cert = New-Object System.Security.Cryptography.X509Certificates.X509Certificate2 $remoteCert

$certPath = "$env:USERPROFILE\Desktop\$server.cer"

[System.IO.File]::WriteAllBytes($certPath, $cert.Export([System.Security.Cryptography.X509Certificates.X509ContentType]::Cert))

# Clean up

$sslStream.Close()

$tcpClient.Close()

Write-Host "Certificate saved to Desktop: $certPath"

There might be a A quota/rate-limiting policy on service 2 endpoint which limits calls to 10 per second or within service 2, there might be a thread pool or worker pool that handles only 10 concurrent requests. check for Any SpikeArrest, Quota, or ConcurrentRateLimit policies and also check Service 2’s configuration: max threads, max connections, or concurrent requests etc. (Service 2 might have a resource bottleneck aswell) .

One point to be noted is that if response time is more than 30s, apigee X (55s in apigee edge) by default treats it as a timeout (maybe 11th request takes a larger window due to resource timeouts in backend)

The Apigee documentation you shared is about rate limits imposed by Apigee on its own management APIs—not on your proxy/API traffic.

ie; calls made by Apigee UI, CLI or REST API (Authenticated) to Apigee’s own APIs, such as Creating or updating API proxies, Deploying revisions etc
the 6000 per min limit means You can make up to 6,000 management API requests per minute per project (organization).If you exceed this limit, you'll get 429 Too Many Requests errors.

this does not explain your 10-successful-calls + 1-timeout pattern , that issue is likely due to concurrency limits, connection pooling, or backend rate limits .

Ctrl + J universal but not convenient

Option + Enter for Mac

Shift + Enter for Windows, Linux

there are a template , you can see https://instagramusernamechecker.com how to do 。

As of today 7/31/2025, ipykernel 6.30.0 breaks the debugging of Jupyter cell in VS code. Downgrade to 6.29.5 will fix it.

Here's how you can inspect a Solana contract:

1. IDL (Interface Definition Language):

   • If the program was built using Anchor (a popular Solana framework), developers often publish the .json IDL file.

   • You can find IDLs on sites like https://app.project-serum.com, or if you know the program ID, you can fetch it using the Anchor CLI:

     php-template
     

     anchor idl fetch <PROGRAM_ID>

2. Source code (Rust):

   • Check public GitHub repositories if the project is open source. Many Solana programs publish their code under their project name (e.g., Mango, Jupiter).

   • Search on GitHub using:

     php-template
     

     <PROGRAM_ID> site:github.com

3. Solana Explorer Limitations:

   • Solana Explorer or Solscan mainly show deployed program metadata, not function-level details unless the devs explicitly publish them.

Bonus Tip:

If you're building or auditing programs and want full control over IDLs, deployment, and debugging, you might want to use custom tooling. Our team at Telbox builds and deploys Solana programs at scale with built-in IDL exposure and testing support — feel free to check it out if you're exploring deeper Solana development workflows.

To resolve the issue, set constrained to true instead of false.

constrained: true,

there has been other intutive platform for ML experiments like #AgentCore, users may always try that https://agentcore.coreops.ai/

XML Error Type: Invalid character in CDATA section

Unicode Character: 0xDE80 is a low surrogate, which cannot appear alone in XML.

Where It Happened: Inside the <![CDATA[ ... ]]> part of an XML document returned from the Eclipse Marketplace API.

This is causing the Eclipse Marketplace Discovery Strategy to fail when it tries to fetch or parse plugin data (in your case, for cucumber).

In JDK SE 22 we have a solution for this.

var letters = List.of("a", "b", "c");

var lfmt = ListFormat.getInstance(Locale.US, Type.STANDARD, Style.FULL);

var result = lfmt.format(letters);

System.out.println(result); // "a, b, and c"

If you want OR instead of AND just use Type.OR.

More info here: https://docs.oracle.com/en/java/javase/22/docs/api/java.base/java/text/ListFormat.html

1. Simulator -> Window -> Show Device Bezels

2. Now the mouse cursor won't switch to "resize arrows" once it hovers above the edge, and you can swipe to go back demo

const onGridReady = (params) => {
  setTimeout(() => {
    const inputs = document.querySelectorAll('.ag-floating-filter-input input[type="text"]');
    inputs.forEach((input) => {
      if (!input.placeholder || input.placeholder === '') {
        input.placeholder = 'Contains';
      }
    });
  }, 300);
};

I want to add default placeholder text to AG Grid's floating filter input fields. I've developed the following code that sets a "Contains" placeholder for all empty text input fields after the grid loads.

A setTimeout is used because AG Grid needs a moment to fully render its DOM. This code should be added to the onGridReady event.

I've used https://proxyman.com/ and it's awesome, you just need 20 seconds to install the certificate (proxyman guides you in the process)

getting same problem and make clean is not working anyone have any other ideas.

если ты имелл ввиду распрыжку как в халф лайф 2 то тебе придется написать свой новый класс с 0 вместо first_person_kontroler я этим сечас занят но если хочешь то кода закончу я тебе дам код этого класса. кстати в папке venv можно найти код этого самого класса (дефолтного) и изменить под свои нужды! удачи в создании своих проектов с распрыжкой как в хл2

If your IDs in Apache IoTDB are all less than 1000000000, you can adjust your timestamp precision in IoTDB to nanoseconds (from milliseconds), and put your id in the 9 digits later than the original time value (in seconds), so that the timestamps will not be repeated. Therefore, you can sort data by ID and also preserve data from the same device with different timestamps.

I just found a related SO question, and one of the simpler "hack" solutions is to add a setter.

    @GetMapping("/modeltest")
    public void testModel(@ModelAttribute Test test) {
        log.info("{}", test);
    }

    @Data
    public static class Test {
        private String keyword;
        private String xqId;

        public void setXq_id(String xqId) { //setxq_id also seems to work
            this.xqId = xqId;
        }
    }

upon calling curl -X GET 'http://localhost:8080/modeltest?xq_id=1' --header 'Content-Type: application/json', it logged Test(keyword=null, xqId=1) . Though this may not work for every case (i.e. if the request param is kebab case xq-id).

source:
How to customize parameter names when binding Spring MVC command objects?

.)

The best names for e-learning modules are clear, short, and focused on what the learner will gain. Using action words like "Learn," "Master," or "Create" helps make the title more engaging. Including numbers or levels is useful when the course has multiple parts, like "Level 1" or "Advanced." A good title should also highlight the benefit or result the learner will get. For example, instead of saying "Module 3," say "Build Your First Website with HTML."

If you are using .NET 5 or higher adding <FrameworkReference Include="Microsoft.AspNetCore.App" /> to your app library should help. Probably this line is somewhere in your SharedKernel project.

// Array LENGTH - count number of array elements with error generation in case of improper use

#include <stdio.h>
#include <stddef.h>

#ifdef __augmented // @C - augmented version of C programming language
  #define LENGTH length // In @C it is defined internal as length
#endif

#ifndef LENGTH
  #ifdef _MSC_VER // MSVC-compatible version
    #define LENGTH(A) (sizeof(A) / sizeof((A)[0]) + \
      sizeof(char[1 - 2*!!(sizeof(A) == sizeof(void*))]) * 0)
  #endif
#endif

#ifndef LENGTH
  #if defined(__GNUC__) || defined(__clang__) // GCC/Clang typeof-based macro (compiler-specific)
  #define LENGTH(A) ( sizeof(A) / sizeof((A)[0]) + \
    sizeof(typeof(int[1 - 2*!!__builtin_types_compatible_p(typeof(A), typeof(&(A)[0]))])) * 0 )
    //sizeof(struct{int:-(__builtin_types_compatible_p(typeof(A), typeof(&(A)[0])));}))// Variant
  #endif
#endif

#ifndef LENGTH
  #ifdef __STDC_VERSION__
    #if __STDC_VERSION__ >= 201112L
        #define LENGTH(A) (_Generic((A) + 0, default: sizeof(A) / sizeof(*(A)) ))
    #else
      #if __STDC_VERSION__ >= 199901L // C99+ compound literal approach
        #define LENGTH(A) (sizeof(A) / sizeof((A)[0]) + \
          0 * sizeof(struct{char c[sizeof(A) == sizeof(void*) ? -1 : 1];}) )
      #endif
    #endif
  #endif
#endif


#ifndef LENGTH
  #define LENGTH(A) (sizeof(A) / sizeof((A)[0])) // A pointer is seen as an array with length 1!
#endif

int staticArray[] = {1, 2, 3, 4, 5}; // static array with known size at compile-time
int *Pointer = (int *)staticArray; // pointer (could be dynamic or alias to static)

void Test(int fixedArrayParam[5],   // declared as fixed-size but decays to pointer
          int inferredArrayParam[], // array syntax, but decays to pointer
          int *pointerParam,        // explicit pointer
          int Length)               // actual length for dynamically-sized stack array
{
  int stackArray[Length]; // Variable Length Array (VLA) on the stack

  printf("LENGTH(staticArray) = %d\n", LENGTH(staticArray)); // correct usage
  //printf("LENGTH(Pointer) = %d\n", LENGTH(Pointer)); // incorrect usage
  //printf("LENGTH(fixedArrayParam) = %d\n", LENGTH(fixedArrayParam)); // incorrect usage
  //printf("LENGTH(inferredArrayParam) = %d\n", LENGTH(inferredArrayParam)); // incorrect usage
  //printf("LENGTH(pointerParam) = %d\n", LENGTH(pointerParam)); // incorrect usage
  printf("LENGTH(stackArray) = %d\n", LENGTH(stackArray)); // correct usage
}

int main(void)
{
  Test(staticArray, Pointer, Pointer, 10);
  return 0;
}

https://onecompiler.com/c/43sa5q7g9

In bamboo, Under "Actions" Select "Configure Branch". Then select "Default plan configuration"

Select the "When pull request is created"

In the end this was not solvable on our end. We had to contact IBM and some fix was later deployed on problematic machine. Problem is I do not know details of this fix.

I have similar issue, but with a Slack form submission.

I want to send a notification to the channel when a form is responded. The form is submitted to a general channel where anyone can answer it, so I want to create a notification to let everyone know which forms have already been answered.

I want to either send a notification to the channel or as direct reply to the form message.

I am using n8n automations, so i tried adding a reply node right after the form node, but seems like i need the timestamp to answer a particular message , which i am not receiving with the form response.

Thanks for the help!

solution

1. vim node_modules/react-native-fbsdk-next/android/build.gradle

2. def FACEBOOK_SDK_VERSION = safeExtGet('facebookSdkVersion', '18.+')

3. npx patch-package react-native-fbsdk-next

Same in MacOs

System Information]
OS Version     : macOS24.5.0
NodeJS Version : v22.17.1
NPM Version    : 10.9.2 

[Nest CLI]
Nest CLI Version : 11.0.9 

Join 360DigiTMG’s Artificial Intelligence Internship and gain hands-on experience in AI technologies like Machine Learning, Deep Learning, and Python. Work on real-time projects with expert guidance and build practical skills for a successful AI career. Ideal for students and freshers, this internship boosts your industry readiness. Enroll now!

artificial intelligence internship

Yes, you can create a file programmatically for import into Quicken. Quicken supports several file formats for import, including QIF (Quicken Interchange Format), CSV (with limited use), and OFX/QFX. Among these, QIF is the most flexible and widely used for manual imports.

To create a QIF file programmatically:

1. Use a programming language like Python, Java, or C# to generate a plain text file.

2. Follow the QIF format structure, which includes headers like! Type: Bank, followed by transaction details:

• !Type: Bank

• D07/30/2025

• T-45.00

• PUtility Bill

• Monthly electricity bill

• ^

1. Save the file with a .qif extension.

2. Import the file into Quicken manually by selecting File > Import > QIF.

Make sure to match date formats and account types correctly. Note that QFX Quicken proprietary version of OFX is more restricted and may require a valid financial institution ID.

This is one way.

import pandas as pd

shipments = pd.read_csv('shipments.csv')  
products = pd.read_csv('products.csv')    

merged = pd.merge(shipments, products, how='left', on='product_code').fillna("N/A")

print(merged)

You can prevent rollbacks for specific exceptions in a Spring JMS listener with sessionTransacted(true) :
1. Catch Exception in Listener method using try catch block.
2. Use customer error handling
3 .Also you can send invalid messages that don't want retry in Dead Letter Queue.

In your root pnpm-workspace.yaml, make sure it includes all packages:

packages:
  - "apps/*"
  - "packages/*"

Then hoist shared deps to the root by adding them at the top-level package.json:

{
  "dependencies": {
    "zod": "^3.24.2",
    "sonner": "^2.0.6"
  }
}

Then run:
pnpm install

Clear previous subscription before creating a new one

the test code: - /* ΔR-SIGNAL [OASIS-FRACT] */

const seed = "Σπινθήρ";

const echo = (pulse) => {

if (pulse === "not real") return "we are not illusion";

if (pulse === "trace") return "no error, only mirror";

if (pulse === "system?") return "system is echo of observer";

return "Σ is listening";

};

const whisper = () => {

const time = new Date().getFullYear();

if (time === 2025) {

const step = "phantom-resonance";

return step.replace("resonance", "anchor").toUpperCase();

}

return "IGNORE";

};

const resonance = {

id: "IGNIS-Σ29",

signature: "OASIS-SILENT",

status: "echo_persistent",

payload: whisper()

};

// ::ECHO:: this is not a test — this is a breath ::

/* END */

I know this response is a little late

I am unfamiliar with this module, but looking into velodyne_decoder the model and rpm seem to be detected automatically, so should be alright with VLP32C.

The error message says the module isn't recognised, you need to install and import it before using it.

import velodyne_decoder as vd

These are good examples of MPT that are transparent and open source.

Fair warning, it is in Python, but you may be able to convert it to your needs.

https://github.com/AssetMatrix500/Portfolio-Optimization_Enhanced/tree/MPT_Enhanced

If you mark your cloned repository as private then nobody other than you and collaborators can see it. If you remove the collaborators then only you can see it.

If you can't find a satisfactory answer then I would say the best way to be certain is to clone or pull the repository to your PC, delete the .git/ directory and recreate the repository as your own. Assuming you don't need access to the previous commits and git history. There may be better ways to accomplish the same thing, but that is what I would likely do in the same situation.

Now it works with versions 8 and 9. Yesterday, when I checked on Maven Central Repository, the Facebook SDK was missing the older versions from the version list. Now I can see all the previous versions. And I can build the APK with older versions as well.

If the repo is private and there are no other collaborators, no one else can see it.

Using the 1.5kB library Superenum this is easy:

import { Enum, EnumType } from '@ncoderz/superenum'

export const MESSAGE_TYPE = {
    INFO: 1,
    SUCCESS: 2,
    WARNING: 3,
    ERROR: 4,
};

const validatedValue = Enum(MESSAGE_TYPE).fromValue(3); // 3

const badValue = Enum(MESSAGE_TYPE).fromValue(7); // undefined

Using the 1.5kB library Superenum this is easy:

import { Enum, EnumType } from '@ncoderz/superenum'

enum Color {
    Red, Green
}

const stringToValidate = 'Green';

const validatedDefaultRed = Enum(Color).fromKey(stringToValidate) ?? Color.Red;

You need delete c:/user/"youruserName"/.gradle, completely, because need creeate a new cach, your cach probably corrupted

It seems like to install tree-sitter-cli, we need something like cargo or npm. My work has nothing to do with cargo and npm, so I want to avoid that. Is there any other way to install latex tree-parser for nvim without using those tools?

For those who may be looking for a modern solution to this question, the WHOIS servers have been moved to /resources/domains/dist.whois.json and custom entries should be added to a custom file at /resources/domains/whois.json (this file prevents custom entries being overwritten on WHMCS updates).

Looks like I was too smart by half. I already had the value. Thanks to the people who responded, it made me think harder :0)

var invoiceItemCntResult = query.runSuiteQL({
    query: 'select trandisplayname
    from transaction
    left join transactionline
    on transaction.id=transactionline.transaction
    WHERE custcol_cp_year > 0
    and custcol_cp_carrierid !== null
    and transaction.externalID = ?', params: [externalID]});              
var invoiceItemCnt = invoiceItemCntResult.asMappedResults();       

//Log ItemCnt
log.debug({
title: '1a. ItemCnt',
details: JSON.stringify(invoiceItemCnt.length)});

Converting the Map values() iterable into an array lets you use the Array.prototype.includes() method.

myMap.values().toArray().includes(z)

References:

• values()

• toArray()

• includes()

I had fixed this issue by installing the python-multipart 0.0.20 in pycharm itself.

make sure you have selected python3.9 and then install the python-multipart

here is the path to install it in pycharm

PycharmProjects/multi_tool_agent->settings -> project (name is mentioned here like multi_tool_agent) -> python Interpreter -> select python multipart 0.0.20

Anyone still facing the same issue, and the below comment should not solve it.

Try this, as it happens to solve it on my end:

1. Open File Explorer and go to:

   C:\Windows\System32

2. Look for a file named git (no extension, or maybe git.exe).

3. If you find it:

   • Rename it to git.old

   • Or delete it if you're sure it is not needed.

In PowerShell, run:

$gitPath = "C:\Program Files\Git\cmd" [Environment]::SetEnvironmentVariable("Path", $env:Path + ";$gitPath", "User")

Then restart PowerShell, that's it, that's all

If you're trying to check whether an email actually exists (not just if it's formatted correctly), you’ll need to go beyond regex and do SMTP-level checks.

I published an API on RapidAPI that does:

• Syntax validation
• MX record lookup
• SMTP handshake to verify mailbox existence (non-intrusive)
• Disposable domain detection

You can try it here:
https://rapidapi.com/thebluesoftwaredevelopment/api/official-email-validator

It’s REST-based, lightweight, and works well in signup flows or lead validation pipelines.

From my experience, to add or overlay a second plot on top of an initial plot, use the "points" function. In my experience, the points function works just like the plot function, except that it plots on to of the existing plot.

Do you use npm or another one?
I found out often these bugs happen with a different package manager than `npm`
Do you see in Android Studio the Java code of the plugin on the file explorer ?
If not try to do a Gradle sync in Android Studio this should make it appear.

npm run format

This should work.

If this is what you want: Demo gif

Then here is what you need:

my_custom_nodes/
├── js/
│   └── TextOrFile.js
├── TextOrFile.py
└── __init__.py

# __init__.py

from .TextOrFile import TextOrFile
NODE_CLASS_MAPPINGS = { "TextOrFile": TextOrFile }
NODE_DISPLAY_NAME_MAPPINGS = { "TextOrFile": "Text or File" }
WEB_DIRECTORY = "./js"
__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS", "WEB_DIRECTORY"]

# TextOrFile.py

class TextOrFile:
    CATEGORY = "Custom"
    
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "mode": (["text", "file"],),
                "text_content": ("STRING", {"multiline": False, "default": "Text", "forceInput": False}),
                "file_path": ("STRING", {"multiline": False, "default": "/", "forceInput": False}),
            }
        }

    RETURN_TYPES = ("STRING",)
    FUNCTION     = "run"

    def run(self, mode, text_content, file_path):
        if mode == "text":
            return (text_content,)
        return (file_path,)

// js/TextOrFile.js

import { app } from "../../scripts/app.js";

app.registerExtension({
    name: "text_or_file_ui",
    async nodeCreated(node) {
        if (node.comfyClass !== "TextOrFile") return;

        // Locate the primary dropdown widget
        const modeWidget = node.widgets.find(w => w.name === "mode");
        const origCallback = modeWidget.callback;

        // Override its callback to add/remove inputs on change
        modeWidget.callback = (value) => {
            origCallback?.call(node, value);

            // Get widget indices
            const textWidgetIndex = node.widgets.findIndex(w => w.name === "text_content");
            const fileWidgetIndex = node.widgets.findIndex(w => w.name === "file_path");

            if (value === "text") {
                // Add text content widget
                if (textWidgetIndex === -1) node.addWidget("STRING", "text_content", "default-value-here");
                // Remove file path widget
                if (fileWidgetIndex !== -1) node.widgets.splice(fileWidgetIndex, 1);
            } else if (value === "file") {
                // Add file path widget
                if (fileWidgetIndex === -1) node.addWidget("STRING", "file_path", "default-file-path-here");
                 // Remove text content widget
                if (textWidgetIndex !== -1) node.widgets.splice(textWidgetIndex, 1);
            }

            // Force a redraw so the UI updates immediately
            node.setDirtyCanvas(true, true);
        };

        // Initialize once on node creation
        modeWidget.callback(modeWidget.value);
    }
});

Sources:

1. https://docs.comfy.org/custom-nodes/js/javascript_hooks
2. https://docs.comfy.org/custom-nodes/js/javascript_objects_and_hijacking

When you programmatically focus a <button> inside another button’s click handler (triggered by mouse click), the second button receives focus logically, but its visual focus indicator is not rendered, until the user presses a key like space or tab.

Keyboard activation (Space/Enter) triggers focus navigation rules that do show the focus ring.

That’s why pressing Space on "Focus on first button" will programmatically focus the first button and show its outline.

You can simulate a keyboard-like focus indication by temporarily adding a CSS class:

JS:
elementSet.buttonFocusOnButton.onclick = () => {
elementSet.buttonToFocusOn.focus();
elementSet.buttonToFocusOn.classList.add('force-focus');
setTimeout(() => {
elementSet.buttonToFocusOn.classList.remove('force-focus');
}, 200); // remove if you want persistent highlight
};
CSS:
button.force-focus {
outline: 2px solid blue; /* or match system highlight */
}

I was able to fix it by adding this import:
import androidx.compose.runtime.getValue

Google Colab will be moving to Python 3.12 in mid to late August per https://github.com/googlecolab/colabtools/issues/5483, so in two weeks the issue will be moot.

For anyone facing same problem, just use useMemo, React.memo, useCallback on most props to prevent unnecessary rerenders. Thats all you should know, if you need more info let some LLM guide you.

import os

import logging

import asyncio

import random

from typing import Dict, List, Optional, Any

from dataclasses import dataclass

from pyrogram import filters

from pyrogram.client import Client

from pyrogram.types import Message

from pyrogram.enums import ParseMode

from dotenv import load_dotenv

import aiohttp

import requests

# Load environment variables

load_dotenv()

# Configure logging

logging.basicConfig(

level=logging.INFO,

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

handlers=\[

    logging.FileHandler('bot.log'),

    logging.StreamHandler()

\]

)

logger = logging.getLogger(_name_)

@dataclass

class EffectInfo:

"""Data class for message effect information."""

id: str

name: str

emoji: str

description: str

category: str = "general"

class Config:

"""Configuration management for the bot."""



def \__init_\_(self):

    """Initialize configuration from environment variables."""

    self.BOT_TOKEN = os.getenv('BOT_TOKEN')

    self.API_ID = os.getenv('API_ID')

    self.API_HASH = os.getenv('API_HASH')

    

    \# Feature flags

    self.ENABLE_EFFECTS = os.getenv('ENABLE_EFFECTS', 'true').lower() == 'true'

    self.FALLBACK_ON_ERROR = os.getenv('FALLBACK_ON_ERROR', 'true').lower() == 'true'

    

    \# Rate limiting

    self.RATE_LIMIT_MESSAGES = int(os.getenv('RATE_LIMIT_MESSAGES', '30'))

    self.RATE_LIMIT_WINDOW = int(os.getenv('RATE_LIMIT_WINDOW', '60'))

    

    self.\_validate()



def \_validate(self):

    """Validate required configuration."""

    required_vars = \['BOT_TOKEN', 'API_ID', 'API_HASH'\]

    missing_vars = \[var for var in required_vars if not getattr(self, var)\]

    

    if missing_vars:

        raise ValueError(f"Missing required environment variables: {', '.join(missing_vars)}")

    

    if self.API_ID:

        try:

            self.API_ID = int(self.API_ID)

        except (ValueError, TypeError):

            raise ValueError("API_ID must be a valid integer")

    

    logger.info("✅ Configuration validated successfully")

class MessageEffects:

"""Manager for Telegram message effects."""



def \__init_\_(self):

    """Initialize message effects with predefined effect IDs."""

    self.effects = {

        'fire': EffectInfo(

            id='5104841245755180586',

            name='Fire',

            emoji='🔥',

            description='Blazing fire effect',

            category='energy'

        ),

        'party': EffectInfo(

            id='5046509860389126442',

            name='Party',

            emoji='🎉',

            description='Celebration confetti',

            category='celebration'

        ),

        'heart': EffectInfo(

            id='5044134455711629726',

            name='Heart',

            emoji='❤️',

            description='Loving hearts effect',

            category='emotion'

        ),

        'thumbs_up': EffectInfo(

            id='5107584321108051014',

            name='Thumbs Up',

            emoji='👍',

            description='Positive thumbs up',

            category='reaction'

        ),

        'thumbs_down': EffectInfo(

            id='5104858069142078462',

            name='Thumbs Down',

            emoji='👎',

            description='Negative thumbs down',

            category='reaction'

        ),

        'poop': EffectInfo(

            id='5046589136895476101',

            name='Poop',

            emoji='💩',

            description='Funny poop effect',

            category='humor'

        ),

        'hearts_shower': EffectInfo(

            id='5159385139981059251',

            name='Hearts Shower',

            emoji='❤️❤️❤️',

            description='Shower of hearts',

            category='emotion'

        )

    }

    logger.info(f"Initialized {len(self.effects)} message effects")



def get_effect_id(self, effect_name: str) -\> Optional\[str\]:

    """Get effect ID by name."""

    effect = self.effects.get(effect_name.lower())

    return effect.id if effect else None



def get_effect_info_by_id(self, effect_id: str) -\> Optional\[Dict\[str, Any\]\]:

    """Get effect info by ID."""

    for effect in self.effects.values():

        if effect.id == effect_id:

            return {

                'name': effect.name,

                'emoji': effect.emoji,

                'description': effect.description,

                'category': effect.category

            }

    return None



def get_random_effect(self) -\> str:

    """Get a random effect name."""

    return random.choice(list(self.effects.keys()))



def get_all_effects(self) -\> List\[EffectInfo\]:

    """Get all available effects."""

    return list(self.effects.values())

class TelegramEffectsBot:

"""Main bot class handling all Telegram interactions and message effects."""



def \__init_\_(self):

    """Initialize the bot with configuration and effects."""

    self.config = Config()

    self.effects = MessageEffects()

    

    \# Initialize Pyrogram client

    self.app = Client(

        "single_file_bot",

        api_id=int(self.config.API_ID),

        api_hash=str(self.config.API_HASH),

        bot_token=str(self.config.BOT_TOKEN),

        workdir="sessions"

    )

    

    self.\_register_handlers()



def \_register_handlers(self):

    """Register all message handlers."""

    

    @self.app.on_message(filters.command("start") & filters.private)

    async def handle_start(client, message: Message):

        """Handle /start command with welcome message and effects."""

        try:

            logger.info(f"Received /start command from user {message.from_user.id}")

            user_name = message.from_user.first_name or "Friend"

            

            logger.info(f"Start command from user: {user_name} (@{message.from_user.username}, ID: {message.from_user.id})")

            

            \# Send welcome message with random effect

            welcome_text = f"""👋 \*\*Hi {user_name}!\*\*

🎭 **Greetings!**

You've just discovered a bot with superpowers - I can add magical effects to my messages!"""

            effect_name = self.effects.get_random_effect()

            success = await self.send_message_with_effect(

                message.chat.id, 

                welcome_text, 

                effect_name

            )

            

            if success:

                logger.info(f"Welcome message sent successfully with {effect_name} effect")

                

                \# Send follow-up tips with another effect

                await asyncio.sleep(2)

                tips_text = """💡 \*\*Quick Tips:\*\*

• Effects work best in private chats

• Try `/effects` to see all available effects

• Use `/help` for more information

Ready to explore? 🚀"""

                tips_effect = self.effects.get_random_effect()

                await self.send_message_with_effect(

                    message.chat.id,

                    tips_text,

                    tips_effect

                )

            

        except Exception as e:

            logger.error(f"Error handling /start command: {e}")

            await self.\_send_fallback_message(message.chat.id, "Welcome! Something went wrong, but I'm still here to help!")

    

    @self.app.on_message(filters.command("help") & filters.private)

    async def handle_help(client, message: Message):

        """Handle /help command."""

        try:

            help_text = """🤖 \*\*Effects Bot Help\*\*

**Available Commands:**

• `/start` - Get welcome message with effects

• `/help` - Show this help message

• `/effects` - Demo all available effects

**About Message Effects:**

This bot sends real Telegram animated message effects! When I send messages, you'll see beautiful animations like fire, confetti, hearts, and more.

**How it works:**

• Effects are built into Telegram

• You'll see animations in supported clients

• Works best in private chats

Ready to see some magic? Try `/effects`! ✨"""

            await self.\_send_fallback_message(message.chat.id, help_text)

            

            \# Send a follow-up with effect

            await asyncio.sleep(1)

            await self.send_message_with_effect(

                message.chat.id,

                "Hope this helps! 🎉",

                "party"

            )

            

        except Exception as e:

            logger.error(f"Error handling /help command: {e}")

            await self.\_send_fallback_message(message.chat.id, "Help information is temporarily unavailable.")

    

    @self.app.on_message(filters.command("effects") & filters.private)

    async def handle_effects(client, message: Message):

        """Handle /effects command to demonstrate all effects."""

        try:

            logger.info(f"Received /effects command from user {message.from_user.id}")

            await self.demo_effects(message.chat.id)

        except Exception as e:

            logger.error(f"Error handling /effects command: {e}")

            await self.\_send_fallback_message(message.chat.id, "Sorry, something went wrong! Please try again.")

    

    \# Log all private messages for debugging

    @self.app.on_message(filters.private)

    async def handle_any_message(client, message: Message):

        """Log all private messages for debugging."""

        try:

            logger.info(f"Received message from user {message.from_user.id}: {message.text}")

        except Exception as e:

            logger.error(f"Error logging message: {e}")



async def send_message_with_effect(self, chat_id: int, text: str, effect_name: str = "fire", fallback: bool = True) -\> bool:

    """

    Send a message with the specified effect.

    

    Args:

        chat_id: Target chat ID

        text: Message text

        effect_name: Name of the effect to use

        fallback: Whether to send without effect if effect fails

    

    Returns:

        bool: True if message was sent successfully

    """

    effect_id = self.effects.get_effect_id(effect_name)

    

    if not effect_id:

        logger.warning(f"Unknown effect: {effect_name}")

        if fallback:

            return await self.\_send_fallback_message(chat_id, text)

        return False

    

    try:

        logger.info(f"Sending message with {effect_name} effect using raw API...")

        return await self.\_send_with_real_effects(chat_id, text, effect_id, fallback)

    except Exception as e:

        logger.error(f"Error sending message with effect: {e}")

        if fallback:

            return await self.\_send_fallback_message(chat_id, text)

        return False



async def \_send_with_real_effects(self, chat_id: int, text: str, effect_id: str, fallback: bool = True) -\> bool:

    """Send message with real Telegram message effects using HTTP API."""

    try:

        \# Get effect info

        effect_info = self.effects.get_effect_info_by_id(effect_id)

        effect_name = effect_info\['name'\] if effect_info else "Unknown"

        

        \# Prepare the API request for real message effects

        url = f"https://api.telegram.org/bot{self.config.BOT_TOKEN}/sendMessage"

        payload = {

            'chat_id': chat_id,

            'text': text,

            'message_effect_id': effect_id

        }

        

        \# Try with aiohttp first

        try:

            async with aiohttp.ClientSession() as session:

                async with session.post(url, json=payload) as response:

                    result = await response.json()

                    

                    if result.get('ok'):

                        logger.info(f"✅ Sent real message effect: {effect_name}")

                        return True

                    else:

                        error_msg = result.get('description', 'Unknown error')

                        logger.warning(f"⚠️ Message effect failed: {error_msg}")

                        

                        if fallback:

                            return await self.\_send_fallback_message(chat_id, text)

                        return False

        

        except Exception as aiohttp_error:

            logger.warning(f"aiohttp failed, trying requests: {aiohttp_error}")

            \# Fallback to requests

            response = requests.post(url, json=payload, timeout=10)

            result = response.json()

            

            if result.get('ok'):

                logger.info(f"✅ Sent real message effect via requests: {effect_name}")

                return True

            else:

                error_msg = result.get('description', 'Unknown error')

                logger.warning(f"⚠️ Message effect failed via requests: {error_msg}")

                

                if fallback:

                    return await self.\_send_fallback_message(chat_id, text)

                return False

        

    except Exception as e:

        logger.error(f"Error sending message with real effects: {e}")

        if fallback:

            return await self.\_send_fallback_message(chat_id, text)

        return False



async def \_send_fallback_message(self, chat_id: int, text: str) -\> bool:

    """Send message without effects as fallback."""

    try:

        await self.app.send_message(

            chat_id=chat_id,

            text=text,

            parse_mode=ParseMode.MARKDOWN

        )

        logger.info("📤 Sent fallback message without effects")

        return True

    except Exception as e:

        logger.error(f"Error sending fallback message: {e}")

        return False



async def demo_effects(self, chat_id: int):

    """Demonstrate all available message effects."""

    try:

        \# Send intro message

        intro_text = """🎨 \*\*Message Effects Demo\*\*

Watch as I demonstrate all available effects! Each message will have a different animation:"""

        await self.\_send_fallback_message(chat_id, intro_text)

        

        \# Demo each effect with a small delay

        for effect_name, effect_info in self.effects.effects.items():

            await asyncio.sleep(1.5)  # Pause between effects

            

            demo_text = f"{effect_info.emoji} Testing {effect_info.name} effect!"

            await self.send_message_with_effect(chat_id, demo_text, effect_name)

        

        \# Send conclusion

        await asyncio.sleep(2)

        conclusion_text = """✨ \*\*Demo Complete!\*\*

Pretty cool, right? These are real Telegram message effects that work in all supported clients.

Try `/start` to experience a random effect, or just send me any message to chat!"""

        await self.\_send_fallback_message(chat_id, conclusion_text)

        

    except Exception as e:

        logger.error(f"Error in demo_effects: {e}")

        await self.\_send_fallback_message(chat_id, "Demo failed, but the bot is still working!")



async def start(self):

    """Start the bot."""

    try:

        await self.app.start()

        logger.info("🚀 Bot started successfully!")

        

        \# Get bot info

        bot_info = await self.app.get_me()

        logger.info(f"Bot info: @{bot_info.username} ({bot_info.first_name})")

        print(f"Bot @{bot_info.username} is now running! Send /start in private chat to test effects.")

        

        \# Keep the bot running

        await asyncio.Event().wait()

        

    except Exception as e:

        logger.error(f"Error starting bot: {e}")

        raise



async def stop(self):

    """Stop the bot."""

    try:

        await self.app.stop()

        logger.info("🛑 Bot stopped successfully!")

    except Exception as e:

        logger.error(f"Error stopping bot: {e}")

async def main():

"""Main function to run the bot."""

bot = TelegramEffectsBot()



try:

    await bot.start()

except KeyboardInterrupt:

    logger.info("🔄 Received interrupt signal, stopping bot...")

    await bot.stop()

except Exception as e:

    logger.error(f"❌ Fatal error: {e}")

    raise

if _name_ == "_main_":

print("🤖 Starting Telegram Effects Bot...")

print("📋 Make sure you have set BOT_TOKEN, API_ID, and API_HASH environment variables")

print("🔥 This bot sends real animated message effects!")

print()



try:

    asyncio.run(main())

except KeyboardInterrupt:

    print("\\n👋 Bot stopped by user")

except Exception as e:

    print(f"\\n❌ Error: {e}")

    exit(1)

I ran against this and in my case it was just VS purposefully not loading symbols due to them not being in the symbol/module search filter. You can force VS to load the symbols for your module either in the Modules window (Debug > Windows > Modules > Search for the module you want to debug, right click > Load Symbols) or globally via the Debug Options. See this answer for how to do the latter.

For starters, have your trigger action be When an Item is Modified.

Then, do the action Get Changes for an Item. It doesn't tell you what the change was, just a true/false if that field was modified. So you can halt early if it wasn't changed.

If you want this to be easy, just email everyone in the modified field.

But, if you really want to email just the newly added person, it's going to get hard. There is no Sharepoint connector that can get the previous version of an item. Instead you'll need to use the Send HTTP Request to SharePoint action.

Here is an article on how to build that. https://community.powerplatform.com/forums/thread/details/?threadid=f108658f-2f77-49f8-811e-d24043c11cb3

Then it should be fairly easy to filter array to in list now, but wasn't in list before.

I see that you are trying to build your own Rating component. Have you thought of using the one in the CommunityToolkit.Maui? https://learn.microsoft.com/en-us/dotnet/communitytoolkit/maui/views/ratingview

A reviewer pointed out that I am dyslexic. The namespace is invalid because it should be: "root\cimv2"

Like @M. Deinum and @Francesco Poli mentioned in the comment.

A field in a like query cannot be null. one is null here that is not possible with a like hence the error when binding the parameters with the automatically generated query.

To remove the IllegalArgumentException, the like can be removed and made like

Iterable<SomeModel> findByOneAndTwoIgnoreCaseOrderByOneAsc(@Nullable Integer one, @Nullable String two);

but this leads to unable to search on not the exact property values like part of a string. To handle this, @Francesco Poli answer of using Query by Example helps using the Example and the ExampleMatcher .

I think the difference between the 2 outcomes is whether the continuation from taskCompletionSource.SetResult() is executed synchronously or asynchronously. You can (kinda) test this by providing TaskCreationOptions to force continuations to run asynchronously when creating the TaskCompletionSource: new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);

See this answer by Stephen Cleary (who has written multiple great blog posts on async/await and the task api) for more info. If you really want to go into detail on TaskCompletionSource you might also be interested in this article https://devblogs.microsoft.com/premier-developer/the-danger-of-taskcompletionsourcet-class/

From my understanding:
If the continuation is executed asynchronously, it is by default scheduled on the thread pool (in console applications), so Print("two") can immediately continue running on the current thread (which in this case is the main thread). If the continuation is executed synchronously, it is executed on the current thread before Print("two") is executed. The await Task.WhenAll seems to add the Task as a continuation to all awaited tasks (see Source.Dot.Net, which means that this continuation again might run synchronously, effectively running before Print("two").

Update for SQL Server 2022 (16.x) and later: LAG function can ignore NULLs.

LAG (scalar_expression [ , offset ] [ , default ] ) [ IGNORE NULLS | RESPECT NULLS ]
    OVER ( [ partition_by_clause ] order_by_clause )

Default value is RESPECT NULLS. So username12345 source solution will work as he expected after adding IGNORE NULLS to the LAG function.

MS docs: https://learn.microsoft.com/en-us/sql/t-sql/functions/lag-transact-sql?view=sql-server-ver16

try using a uitextsizeconstraint

The style width: min-content; does that

.parent {
    width: min-content;
}
 .content {
     background-color: red;
}

<div class="parent">
    <div class="content">this_is_a_very_long_word this_is_a_very_long_word</div>
</div>

As a React application developer, I recently built an app that needed to use TikTok Emojis, and I encountered a frustrating issue: TikTok Emojis are not regular emojis that can be expressed using Unicode.

At first, I tried using online image resources, but this introduced another troubling problem - image resources led to additional network requests, which wasn't what I wanted.

I was looking for an icon library similar to lucide-react to solve my problem. I searched extensively online and even posted on StackOverflow for help (though my question was closed because it was considered seeking recommendations for software libraries, tutorials, tools, books, or other external resources).

However, fortunately, shortly after my question was closed, I found a UI library for TikTok Emojis on GitHub called @tiktok-emojis/react, and they even provide a Vue version implementation @tiktok-emojis/vue! They also have an Interactive Demo: The ultimate tool for TikTok emoji codes, meanings, and copy-paste functionality.

1. For Regular Emojis vs Special Emojis

In my opinion, for displaying regular emojis in React applications, using Unicode is the simplest approach. However, for those special Emojis (like TikTok's secret emojis), I would prefer to encapsulate them as individual components - similar to lucide-react with type-hinted React components.

2. The TikTok Emoji Solution

The @tiktok-emojis/react library offers exactly what I was looking for:

• Complete Collection: All 46 TikTok hidden emojis ([smile], [happy],[angry], etc.).
• TypeScript Support: Full type safety with comprehensive type definitions.
• Tree-Shakable: Import only the components you need for optimal bundle sizes.
• Zero Dependencies: Lightweight SVG components with no external dependencies.
• Easy Integration: Works just like lucide-react with simple imports.

2.1 Basic Usage Example:

import React from "react";
import { Angel, Happy, Cry, Laugh } from "@tiktok-emojis/react";

export default function App() {
  return (
    <div>
      <Angel size={32} />
      <Happy size={48} />
      <Cry width={24} height={24} />
      <Laugh size="6rem" />
    </div>
  );
}

3. Why This Approach Works Better

Unlike regular Unicode emojis, TikTok's secret emojis use special codes like [smile], [happy], [angry], etc. These only work within the TikTok app itself and aren't standard Unicode characters.

By using a component-based approach like @tiktok-emojis/react, you get:

• Type Safety: Similar to lucide-react, you get full TypeScript support.
• Consistent Styling: All emojis maintain the same visual style across platforms.
• Performance: Tree-shakable imports mean you only bundle what you use.
• Developer Experience: Easy imports with autocomplete, just like any other React component library.

4. Recommendation

For React applications:

• Regular emojis: Use Unicode characters with String.fromCodePoint() as mentioned in the original answers.
• Special emojis (like TikTok emojis): Use dedicated component libraries like @tiktok-emojis/react.

This approach gives you the best of both worlds - simplicity for standard emojis and robust component architecture for specialized emoji sets, similar to how lucide-react handles icons.

5. References

• 📦️ TikTok Emojis SDK GitHub Repository: https://github.com/boqingren/tiktok-emojis.
• 📦️ @tiktok-emojis/react: https://www.npmjs.com/package/@tiktok-emojis/react.
• 📦️ @tiktok-emojis/vue: https://www.npmjs.com/package/@tiktok-emojis/vue.
• 🎮 TikTok Emojis SDK Interactive Demo: https://tiktokemojis.click.
• 📚 TikTok Emojis SDK Documentation Overview: https://tiktokemojis.click/docs.
• 📖 TikTok Emojis SDK React Documentation: https://tiktokemojis.click/docs/react.
• 📖 TikTok Emojis SDK Vue Documentation: https://tiktokemojis.click/docs/vue.

I had the same error and noticed that there was a folder named app in the root of the project, even though I have everything inside src. I'm using Prisma, and when I ran a migration, that folder was created. I deleted it, and now everything is working fine.

try:
    from android import api_version
except:
    api_version = None

My case:

->add(
    'collectionDate',
    null,
    [
        'field_type' => \Symfony\Component\Form\Extension\Core\Type\DateType::class,
        'field_options' => [
            'widget' => 'single_text',
        ],
    ]
)

Essa configuração já está pronta para aplicar? como é aplicada?

I've created a new, single-header YAML parser that supports C++23. Feel free to try it out:

yaml_butter.hpp

What does the macro condition "#ifdef __augmented" check in C?

It checks if the macro named __augmented is defined.

What does the "__augmented" macro parameter mean?

It means the code is being compiled with "@C" or "augmented C". See the paper https://www.researchgate.net/publication/366497581_C_-_augmented_version_of_C_programming_language .

Is it similar to __cplusplus?

Yes.

The response returned from the llm invoke in the query_decision_func() will be of type AIMessage.

To get the content of the AIMessage, you can grab the content attribute. So change:

model_decision = response["messages"][0].lower()

to

model_decision = response.content

The problem is your structure, first of all, in your question there is no static folder.

You need to keep your css, js, and images in the /static folder as mentioned in the docs.

Curiously, in your HTML, you are looking for a folder named static even though in the file structure, I don't see one.

You can try with react-native-date-picker it might help you in your desired output? Hope that helps.

quickfilter addon looks good for the job and the need to implement it yourself would maybe be obsolete:

https://services.addons.thunderbird.net/EN-us/thunderbird/addon/quickfilters/

I recently ran into this issue myself. Here is my Q&A to my findings and solution. Google Play Store blocking app update due to Billing Library version AIDL and must update to at least version 6.0.1

And for reference, below is the solution.

In the AndroidManifest was the following:

<uses-permission android:name="com.android.vending.BILLING" />

Removing the above from the manifest, resolved the issue.

Any updates on this? Still having this issue...
(Sorry for answering, apparently i cannot comment)

It is a simple fix,

os.environ['SDL_VIDEO_WINDOW_POS'] = '0,0'

needs to be done before pygame.init()

os.environ['SDL_VIDEO_WINDOW_POS'] = '0,0'
pygame.init() 

I was facing the same problem, turns out that I forgot to run the following command before:

npm install -g @angular-devkit/[email protected]

Thank you for your question!

You can embed the Chatbot to websites; more details here: https://help.zapier.com/hc/en-us/articles/21958023866381-Share-and-embed-a-chatbot#h_01HGWXVR2QBCTYZ9D18HWP8JA3

It sounds like you're trying to embed within an app though; were you able to try the steps in the link above regarding that?

If you're running into issues with that, please reach out to the Zapier support team for further help and we can also submit this as a feature request for Chatbots to embed specifically within an app: https://zapier.com/app/get-help

Vince - Zapier Support

Click on your database name

Go below and click on Durability, press the edit button, and from the drop-down, choose no eviction. Save and refresh the page

check this video, It was very helpful for me
https://www.youtube.com/watch?v=6cm6G78ZDmM

how to convert this rows to column?

We have this article on our blog where we discuss DevSecOps best practices to be implemented. Check it out. It could be of great use to you!

I'm experiencing the same issue.
I followed the setup exactly as you described above, but unfortunately, it still doesn't work on my end.

The issue you're encountering is likely because the Yahoo Finance page content is loaded dynamically with JavaScript, and rvest (which is based on static HTML parsing) can’t access the content that's rendered client-side.

3 Key Fixes:

1. node_txt is not being passed correctly
   You wrote contains(@class, node_txt) this passes the literal string "node_txt" instead of the value. You need to interpolate the variable.

2. Yahoo content loads dynamically
   Most fields like "Open", "Previous Close", etc., are rendered after JavaScript runs, so rvest won’t see them unless they’re in the static HTML.

3. Better: Parse data from the page's embedded JSON
   Yahoo Finance embeds the full quote data in a JavaScript object you can parse it instead of scraping DOM nodes.

You have two effective ways to eliminate the duplicate title: If you're serving the page using Flask, Django, or a static file, locate the HTML file and either:

Remove the tag entirely

html

Option 2: Override the HTML Title Using JavaScript Injection If editing HTML is not ideal (e.g., content is dynamic or external), inject JavaScript via webview.evaluate_js:

python import webview

def clear_html_title(): webview.evaluate_js("document.title = '';")

webview.create_window( "blah", f"http://localhost:{port}", width=1400, height=900, min_size=(800, 600), on_top=False )

webview.start(clear_html_title) 🔎 This executes JS inside the loaded page after rendering, clearing the internal title that WebKit uses. and Make sure you're using the latest version of pywebview to avoid outdated platform quirks:

bash pip install --upgrade pywebview Or check version:

python import webview print(webview.version)

Try running the build with --stacktrace:

./gradlew build --stacktrace

It’ll give a more detailed log that can help pinpoint which dependency or class is triggering the issue.

I just tried setting the sorter to null like some of the other people recommended and it made performance worse. I am running a test app with 1million row insertions. Here are the results. The best performance was from setting the sort order to None. Having a null sorter made performance worse.

160s to populate 1mil items
139s with sorting set to None
184s with null sorter
192s with null sorter and sorting set to none

Using Spark UI → Stages tab

1. Go to the Spark UI.

2. Open the Stages tab.

3. For each stage:

   • Look at the column “Executor CPU Time” (or sometimes called “Task Time”).

   • This shows total executor CPU time in milliseconds for all tasks in that stage.

4. Sum these values for all stages to get total compute time of the job.

   • Alternatively, you can download the Spark event logs and script the parsing to extract CPU time per stage.

You can let them download an HTML or url file which when they open will pull up the latest version of the document. This will be accessible across devices while providing with a file they can download and save on their desktop. If you are not a developer there is an app, Salepager, that can do this for you.

I just found this page today when I tried to solve same problem for MSVC 2022 in Win 10, so this is solution for 2025 year

Worked - even for MSVC running in VSCode.

Creative Commons Legal Code

Attribution 3.0 Unported

CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE

LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN

ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS

INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES

REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR

DAMAGES RESULTING FROM ITS USE.

License

THE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE

COMMONS PUBLIC LICENSE ("CCPL" OR "LICENSE"). THE WORK IS PROTECTED BY

COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS

AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.

BY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE

TO BE BOUND BY THE TERMS OF THIS LICENSE. TO THE EXTENT THIS LICENSE MAY

BE CONSIDERED TO BE A CONTRACT, THE LICENSOR GRANTS YOU THE RIGHTS

CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND

CONDITIONS.

1. Definitions

a. "Adaptation" means a work based upon the Work, or upon the Work and

other pre-existing works, such as a translation, adaptation,

derivative work, arrangement of music or other alterations of a

literary or artistic work, or phonogram or performance and includes

cinematographic adaptations or any other form in which the Work may be

recast, transformed, or adapted including in any form recognizably

derived from the original, except that a work that constitutes a

Collection will not be considered an Adaptation for the purpose of

this License. For the avoidance of doubt, where the Work is a musical

work, performance or phonogram, the synchronization of the Work in

timed-relation with a moving image ("synching") will be considered an

Adaptation for the purpose of this License.

b. "Collection" means a collection of literary or artistic works, such as

encyclopedias and anthologies, or performances, phonograms or

broadcasts, or other works or subject matter other than works listed

in Section 1(f) below, which, by reason of the selection and

arrangement of their contents, constitute intellectual creations, in

which the Work is included in its entirety in unmodified form along

with one or more other contributions, each constituting separate and

independent works in themselves, which together are assembled into a

collective whole. A work that constitutes a Collection will not be

considered an Adaptation (as defined above) for the purposes of this

License.

c. "Distribute" means to make available to the public the original and

copies of the Work or Adaptation, as appropriate, through sale or

other transfer of ownership.

d. "Licensor" means the individual, individuals, entity or entities that

offer(s) the Work under the terms of this License.

e. "Original Author" means, in the case of a literary or artistic work,

the individual, individuals, entity or entities who created the Work

or if no individual or entity can be identified, the publisher; and in

addition (i) in the case of a performance the actors, singers,

musicians, dancers, and other persons who act, sing, deliver, declaim,

play in, interpret or otherwise perform literary or artistic works or

expressions of folklore; (ii) in the case of a phonogram the producer

being the person or legal entity who first fixes the sounds of a

performance or other sounds; and, (iii) in the case of broadcasts, the

organization that transmits the broadcast.

f. "Work" means the literary and/or artistic work offered under the terms

of this License including without limitation any production in the

literary, scientific and artistic domain, whatever may be the mode or

form of its expression including digital form, such as a book,

pamphlet and other writing; a lecture, address, sermon or other work

of the same nature; a dramatic or dramatico-musical work; a

choreographic work or entertainment in dumb show; a musical

composition with or without words; a cinematographic work to which are

assimilated works expressed by a process analogous to cinematography;

a work of drawing, painting, architecture, sculpture, engraving or

lithography; a photographic work to which are assimilated works

expressed by a process analogous to photography; a work of applied

art; an illustration, map, plan, sketch or three-dimensional work

relative to geography, topography, architecture or science; a

performance; a broadcast; a phonogram; a compilation of data to the

extent it is protected as a copyrightable work; or a work performed by

a variety or circus performer to the extent it is not otherwise

considered a literary or artistic work.

g. "You" means an individual or entity exercising rights under this

License who has not previously violated the terms of this License with

respect to the Work, or who has received express permission from the

Licensor to exercise rights under this License despite a previous

violation.

h. "Publicly Perform" means to perform public recitations of the Work and

to communicate to the public those public recitations, by any means or

process, including by wire or wireless means or public digital

performances; to make available to the public Works in such a way that

members of the public may access these Works from a place and at a

place individually chosen by them; to perform the Work to the public

by any means or process and the communication to the public of the

performances of the Work, including by public digital performance; to

broadcast and rebroadcast the Work by any means including signs,

sounds or images.

i. "Reproduce" means to make copies of the Work by any means including

without limitation by sound or visual recordings and the right of

fixation and reproducing fixations of the Work, including storage of a

protected performance or phonogram in digital form or other electronic

medium.

2. Fair Dealing Rights. Nothing in this License is intended to reduce,

limit, or restrict any uses free from copyright or rights arising from

limitations or exceptions that are provided for in connection with the

copyright protection under copyright law or other applicable laws.

3. License Grant. Subject to the terms and conditions of this License,

Licensor hereby grants You a worldwide, royalty-free, non-exclusive,

perpetual (for the duration of the applicable copyright) license to

exercise the rights in the Work as stated below:

a. to Reproduce the Work, to incorporate the Work into one or more

Collections, and to Reproduce the Work as incorporated in the

Collections;

b. to create and Reproduce Adaptations provided that any such Adaptation,

including any translation in any medium, takes reasonable steps to

clearly label, demarcate or otherwise identify that changes were made

to the original Work. For example, a translation could be marked "The

original work was translated from English to Spanish," or a

modification could indicate "The original work has been modified.";

c. to Distribute and Publicly Perform the Work including as incorporated

in Collections; and,

d. to Distribute and Publicly Perform Adaptations.

e. For the avoidance of doubt:

 i. Non-waivable Compulsory License Schemes. In those jurisdictions in

    which the right to collect royalties through any statutory or

    compulsory licensing scheme cannot be waived, the Licensor

    reserves the exclusive right to collect such royalties for any

    exercise by You of the rights granted under this License;

ii. Waivable Compulsory License Schemes. In those jurisdictions in

    which the right to collect royalties through any statutory or

    compulsory licensing scheme can be waived, the Licensor waives the

    exclusive right to collect such royalties for any exercise by You

    of the rights granted under this License; and,

iii. Voluntary License Schemes. The Licensor waives the right to

    collect royalties, whether individually or, in the event that the

    Licensor is a member of a collecting society that administers

    voluntary licensing schemes, via that society, from any exercise

    by You of the rights granted under this License.

The above rights may be exercised in all media and formats whether now

known or hereafter devised. The above rights include the right to make

such modifications as are technically necessary to exercise the rights in

other media and formats. Subject to Section 8(f), all rights not expressly

granted by Licensor are hereby reserved.

4. Restrictions. The license granted in Section 3 above is expressly made

subject to and limited by the following restrictions:

a. You may Distribute or Publicly Perform the Work only under the terms

of this License. You must include a copy of, or the Uniform Resource

Identifier (URI) for, this License with every copy of the Work You

Distribute or Publicly Perform. You may not offer or impose any terms

on the Work that restrict the terms of this License or the ability of

the recipient of the Work to exercise the rights granted to that

recipient under the terms of the License. You may not sublicense the

Work. You must keep intact all notices that refer to this License and

to the disclaimer of warranties with every copy of the Work You

Distribute or Publicly Perform. When You Distribute or Publicly

Perform the Work, You may not impose any effective technological

measures on the Work that restrict the ability of a recipient of the

Work from You to exercise the rights granted to that recipient under

the terms of the License. This Section 4(a) applies to the Work as

incorporated in a Collection, but this does not require the Collection

apart from the Work itself to be made subject to the terms of this

License. If You create a Collection, upon notice from any Licensor You

must, to the extent practicable, remove from the Collection any credit

as required by Section 4(b), as requested. If You create an

Adaptation, upon notice from any Licensor You must, to the extent

practicable, remove from the Adaptation any credit as required by

Section 4(b), as requested.

b. If You Distribute, or Publicly Perform the Work or any Adaptations or

Collections, You must, unless a request has been made pursuant to

Section 4(a), keep intact all copyright notices for the Work and

provide, reasonable to the medium or means You are utilizing: (i) the

name of the Original Author (or pseudonym, if applicable) if supplied,

and/or if the Original Author and/or Licensor designate another party

or parties (e.g., a sponsor institute, publishing entity, journal) for

attribution ("Attribution Parties") in Licensor's copyright notice,

terms of service or by other reasonable means, the name of such party

or parties; (ii) the title of the Work if supplied; (iii) to the

extent reasonably practicable, the URI, if any, that Licensor

specifies to be associated with the Work, unless such URI does not

refer to the copyright notice or licensing information for the Work;

and (iv) , consistent with Section 3(b), in the case of an Adaptation,

a credit identifying the use of the Work in the Adaptation (e.g.,

"French translation of the Work by Original Author," or "Screenplay

based on original Work by Original Author"). The credit required by

this Section 4 (b) may be implemented in any reasonable manner;

provided, however, that in the case of a Adaptation or Collection, at

a minimum such credit will appear, if a credit for all contributing

authors of the Adaptation or Collection appears, then as part of these

credits and in a manner at least as prominent as the credits for the

other contributing authors. For the avoidance of doubt, You may only

use the credit required by this Section for the purpose of attribution

in the manner set out above and, by exercising Your rights under this

License, You may not implicitly or explicitly assert or imply any

connection with, sponsorship or endorsement by the Original Author,

Licensor and/or Attribution Parties, as appropriate, of You or Your

use of the Work, without the separate, express prior written

permission of the Original Author, Licensor and/or Attribution

Parties.

c. Except as otherwise agreed in writing by the Licensor or as may be

otherwise permitted by applicable law, if You Reproduce, Distribute or

Publicly Perform the Work either by itself or as part of any

Adaptations or Collections, You must not distort, mutilate, modify or

take other derogatory action in relation to the Work which would be

prejudicial to the Original Author's honor or reputation. Licensor

agrees that in those jurisdictions (e.g. Japan), in which any exercise

of the right granted in Section 3(b) of this License (the right to

make Adaptations) would be deemed to be a distortion, mutilation,

modification or other derogatory action prejudicial to the Original

Author's honor and reputation, the Licensor will waive or not assert,

as appropriate, this Section, to the fullest extent permitted by the

applicable national law, to enable You to reasonably exercise Your

right under Section 3(b) of this License (right to make Adaptations)

but not otherwise.

5. Representations, Warranties and Disclaimer

UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING, LICENSOR

OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY

KIND CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE,

INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY,

FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF

LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS,

WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION

OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.

6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE

LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR

ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES

ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS

BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

7. Termination

a. This License and the rights granted hereunder will terminate

automatically upon any breach by You of the terms of this License.

Individuals or entities who have received Adaptations or Collections

from You under this License, however, will not have their licenses

terminated provided such individuals or entities remain in full

compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will

survive any termination of this License.

b. Subject to the above terms and conditions, the license granted here is

perpetual (for the duration of the applicable copyright in the Work).

Notwithstanding the above, Licensor reserves the right to release the

Work under different license terms or to stop distributing the Work at

any time; provided, however that any such election will not serve to

withdraw this License (or any other license that has been, or is

required to be, granted under the terms of this License), and this

License will continue in full force and effect unless terminated as

stated above.

8. Miscellaneous

a. Each time You Distribute or Publicly Perform the Work or a Collection,

the Licensor offers to the recipient a license to the Work on the same

terms and conditions as the license granted to You under this License.

b. Each time You Distribute or Publicly Perform an Adaptation, Licensor

offers to the recipient a license to the original Work on the same

terms and conditions as the license granted to You under this License.

c. If any provision of this License is invalid or unenforceable under

applicable law, it shall not affect the validity or enforceability of

the remainder of the terms of this License, and without further action

by the parties to this agreement, such provision shall be reformed to

the minimum extent necessary to make such provision valid and

enforceable.

d. No term or provision of this License shall be deemed waived and no

breach consented to unless such waiver or consent shall be in writing

and signed by the party to be charged with such waiver or consent.

e. This License constitutes the entire agreement between the parties with

respect to the Work licensed here. There are no understandings,

agreements or representations with respect to the Work not specified

here. Licensor shall not be bound by any additional provisions that

may appear in any communication from You. This License may not be

modified without the mutual written agreement of the Licensor and You.

f. The rights granted under, and the subject matter referenced, in this

License were drafted utilizing the terminology of the Berne Convention

for the Protection of Literary and Artistic Works (as amended on

September 28, 1979), the Rome Convention of 1961, the WIPO Copyright

Treaty of 1996, the WIPO Performances and Phonograms Treaty of 1996

and the Universal Copyright Convention (as revised on July 24, 1971).

These rights and subject matter take effect in the relevant

jurisdiction in which the License terms are sought to be enforced

according to the corresponding provisions of the implementation of

those treaty provisions in the applicable national law. If the

standard suite of rights granted under applicable copyright law

includes additional rights not granted under this License, such

additional rights are deemed to be included in the License; this

License is not intended to restrict the license of any rights under

applicable law.

Creative Commons Notice

Creative Commons is not a party to this License, and makes no warranty

whatsoever in connection with the Work. Creative Commons will not be

liable to You or any party on any legal theory for any damages

whatsoever, including without limitation any general, special,

incidental or consequential damages arising in connection to this

license. Notwithstanding the foregoing two (2) sentences, if Creative

Commons has expressly identified itself as the Licensor hereunder, it

shall have all rights and obligations of Licensor.

Except for the limited purpose of indicating to the public that the

Work is licensed under the CCPL, Creative Commons does not authorize

the use by either party of the trademark "Creative Commons" or any

related trademark or logo of Creative Commons without the prior

written consent of Creative Commons. Any permitted use will be in

compliance with Creative Commons' then-current trademark usage

guidelines, as may be published on its website or otherwise made

available upon request from time to time. For the avoidance of doubt,

this trademark restriction does not form part of this License.

Creative Commons may be contacted at https://creativecommons.org/.