All perguntas(coding)

Ao executar meu script Scala, vejo um aviso:

> scala upload.scala

SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.

Aqui está meu script:

//> using scala "3"
//> using dep "software.amazon.awssdk:s3:2.31.10"

import software.amazon.awssdk.services.s3.S3Client

@main
def main() = S3Client.builder()

Pergunta : Como posso evitar esse aviso?

Estou tentando calcular uma mediana móvel para cerca de 10.000 sinais, cada um com uma lista de comprimento em torno de 750.

Um exemplo de dataframe se parece com isto:

num_indices = 2000 # Set number of indices

# Generate lists of values (each a list of numbers from 0 to 1)
column_data = [np.random.random(750).tolist() for _ in range(num_indices)] 

# Create DataFrame
df = pd.DataFrame({'values': column_data}, index=range(num_indices))

Encontrei esta implementação que usa np.lib.stride_tricks, mas é um pouco lenta para o meu propósito. Alguém tem uma ideia para um método mais rápido?

def moving_median(signal,n=150):
# Compute rolling median for valid windows
swindow = np.lib.stride_tricks.sliding_window_view(signal, (n,))
b = np.nanmedian(swindow, axis=1)
b_full = np.concatenate([[np.nanmedian(signal)]*(n-1), b]) # Prepend first `n-1` values unchanged
return signal - b_full

E finalmente:

df.iloc[:,0].apply(lambda x: moving_median(x))

Estou com problemas para conectar meu aplicativo Spring Boot ao Redis em um ambiente Docker. Enquanto meu aplicativo se conecta com sucesso ao PostgreSQL na mesma rede Docker, as conexões Redis falham com:

Você pode me ajudar a corrigir esse problema, para que minha aplicação API consiga enviar requisições ao Redis mesmo dentro do Docker.

Obs: Se eu executar meu aplicativo Rest API localmente (não no Docker) e chamar qualquer endpoint que use Redis, ele funciona como esperado, o problema está apenas dentro do Docker.

mensagem:

{
    "apiPath": "uri=/v1/devices/38",
    "errorCode": "INTERNAL_SERVER_ERROR",
    "errorMessage": "Unable to connect to Redis",
    "errorTime": "2025-03-28T16:57:26.309001832"
}

docker-compor:

version: '3.8'

services:
  postgres:
    image: postgres:latest
    environment:
      POSTGRES_DB: devicedb
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: admin
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U admin"]
      interval: 30s
      timeout: 10s
      retries: 5

  redis:
    image: "redis"
    ports:
      - "6379:6379"
    command: redis-server --appendonly yes --requirepass admin  # Added password requirement
    healthcheck:
      test: ["CMD", "redis-cli", "-a", "admin", "ping"]  # Added auth for healthcheck
      interval: 30s
      timeout: 10s
      retries: 5

  app:
    build: .
    ports:
      - "8080:8080"
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    environment:
      SPRING_DATASOURCE_URL: jdbc:postgresql://postgres:5432/devicedb
      SPRING_DATASOURCE_USERNAME: admin
      SPRING_DATASOURCE_PASSWORD: admin
      SPRING_REDIS_HOST: redis
      SPRING_REDIS_PORT: 6379
      SPRING_REDIS_PASSWORD: admin 

volumes:
  postgres_data:

aplicação.propriedades

spring.application.name=ManageDevices

server.port=8080
server.address=0.0.0.0

spring.datasource.url=jdbc:postgresql://postgres:5432/devicedb
spring.datasource.username=admin
spring.datasource.password=admin
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
spring.jpa.hibernate.ddl-auto=update

spring.redis.host=redis
spring.redis.port=6379
spring.redis.password=admin

Quando executo firebase deploy, recebo o seguinte erro:

TypeError Não é possível ler propriedades de nulo (lendo 'length')

O que devo fazer para corrigir isso?

Preciso escrever uma exibição de lista que funcione com dados do proprietário, para Windows, em C. Com os dados fornecidos no momento da criação e sem o estilo OWNERDATA, tudo funciona corretamente.

assim que eu defino o sinalizador OWNERDATA na criação e escrevo o manipulador para a notificação LVN_GETDISPINFO, apenas o item principal funciona, os subitens estão todos errados. Eu depurei e, aparentemente, o Windows pede IDs de subitens completamente fora do intervalo e diferentes toda vez que eu executo. Eu escrevi este pequeno trecho para reproduzir este problema para ver se alguém poderia me ajudar com isso.

#ifndef UNICODE
#define UNICODE
#define _UNICODE
#endif

#include <Windows.h>
#include <CommCtrl.h>
#include <assert.h>
#include <malloc.h>
#include <stdio.h>
#include <stdbool.h>

#pragma comment(lib,"comctl32.lib")
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")

static HWND MainWindowHandle;

LRESULT MainWindowProcedure(HWND WindowHandle, UINT Message, WPARAM wParam, LPARAM lParam)
{
    static unsigned ColumnFormat[5];
    static unsigned ColumnOrder[5];
    static unsigned ColumnCount = 5;

    switch (Message)
    {
        case WM_CREATE:
        {
            for (unsigned index = 0; index < 5; ++index)
            {
                ColumnFormat[index] = LVCFMT_WRAP;
                ColumnOrder[index] = index;
            }
            break;
        }
        case WM_NOTIFY:
        {
            LPNMHDR Notification = (LPNMHDR)lParam;
            switch (Notification->code)
            {
                case LVN_GETDISPINFO:
                {
                    NMLVDISPINFO *DisplayInfo = (NMLVDISPINFO *)lParam;
                    if (DisplayInfo->item.mask & LVIF_COLFMT)
                    {
                        DisplayInfo->item.piColFmt = ColumnFormat;
                        DisplayInfo->item.cColumns = ColumnCount;
                    }
                    if (DisplayInfo->item.mask & LVIF_COLUMNS)
                    {
                        DisplayInfo->item.puColumns = ColumnOrder;
                        DisplayInfo->item.cColumns = ColumnCount;
                    }
                    if (DisplayInfo->item.mask & LVIF_TEXT)
                    {
                        _snwprintf(DisplayInfo->item.pszText, DisplayInfo->item.cchTextMax, L"%u - %u", DisplayInfo->item.iItem, DisplayInfo->item.iSubItem);
                    }
                    if (DisplayInfo->item.mask & LVIF_INDENT)
                        DisplayInfo->item.iIndent = 0;
                    if (DisplayInfo->item.mask & LVIF_STATE)
                    {
                        DisplayInfo->item.state = 0;
                        DisplayInfo->item.stateMask = 0;
                    }
                    DisplayInfo->item.mask |= LVIF_DI_SETITEM;
                    break;
                }
            }
            break;
        }
    }
    return DefWindowProc(WindowHandle, Message, wParam, lParam);
}

int wWinMain(
    HINSTANCE hInstance,
    HINSTANCE hPrevInstance,
    LPWSTR pWideCmdLine,
    int nShowCmd
)
{
    WNDCLASSEX UIWindowClass = { 0 };
    if (UIWindowClass.cbSize == 0)
    {
        UIWindowClass.cbSize = sizeof(UIWindowClass);
        UIWindowClass.style = CS_OWNDC | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
        UIWindowClass.lpfnWndProc = (WNDPROC)MainWindowProcedure;
        UIWindowClass.cbClsExtra = 0;
        UIWindowClass.cbWndExtra = 0;
        UIWindowClass.hInstance = GetModuleHandle(NULL);
        UIWindowClass.hCursor = LoadCursor(NULL, IDC_ARROW);
        UIWindowClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
        UIWindowClass.lpszMenuName = NULL;
        UIWindowClass.lpszClassName = TEXT("MyClass");

        if (RegisterClassEx(&UIWindowClass) == 0)
        {
            return -1;
        }
    }
    INITCOMMONCONTROLSEX ICCE = { 0 };
    if (ICCE.dwSize == 0)
    {
        memset(&ICCE, 0, sizeof(ICCE));
        ICCE.dwSize = sizeof(ICCE);
        ICCE.dwICC = ICC_LISTVIEW_CLASSES | ICC_STANDARD_CLASSES | ICC_TAB_CLASSES | ICC_TREEVIEW_CLASSES;
        if (InitCommonControlsEx(&ICCE) == 0)
        {
            return -1;
        }
    }


    DWORD Style = 0, ExStyle = 0;
    ExStyle |= WS_EX_APPWINDOW;
    Style |= WS_VISIBLE;
    Style |= WS_CLIPSIBLINGS;
    Style |= WS_CLIPCHILDREN;


    HWND NewHWND = CreateWindowEx(
        ExStyle,
        TEXT("MyClass"),
        TEXT("MainWindow"),
        Style,
        10, 10,
        1800, 900,
        NULL,
        NULL,
        GetModuleHandle(NULL),
        NULL);

    if (NewHWND == 0)
        return -1;


    Style = 0;
    ExStyle = 0;
    Style |= WS_TABSTOP;
    Style |= WS_VISIBLE;
    Style |= WS_CHILD;
    Style |= WS_CLIPSIBLINGS;
    Style |= WS_CLIPCHILDREN;
    Style |= LVS_AUTOARRANGE;
    Style |= LVS_SHOWSELALWAYS;
    Style |= WS_BORDER;
    Style |= LVS_OWNERDATA;

    HWND ListViewHandle = CreateWindowEx(
        ExStyle,
        WC_LISTVIEW,
        TEXT("ListView"),
        Style,
        10, 10,
        1500, 800,
        NewHWND,
        NULL,
        GetModuleHandle(NULL),
        NULL);
    if (ListViewHandle == NULL)
        return -1;

    ListView_SetItemCount(ListViewHandle, 20);

    LVTILEVIEWINFO ViewInfo;
    memset(&ViewInfo, 0, sizeof(ViewInfo));
    ViewInfo.cbSize = sizeof(ViewInfo);
    ViewInfo.cLines = 4;
    ViewInfo.dwFlags = LVTVIF_AUTOSIZE;
    ViewInfo.dwMask = LVTVIM_TILESIZE | LVTVIM_COLUMNS;
    ListView_SetTileViewInfo(ListViewHandle, &ViewInfo);

    ListView_SetView(ListViewHandle, LV_VIEW_TILE);

    for (unsigned Index = 0; Index < 5; ++Index)
    {
        LVCOLUMN NewColumn;
        memset(&NewColumn, 0, sizeof(NewColumn));
        NewColumn.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
        NewColumn.fmt = LVCFMT_LEFT;
        NewColumn.cx = 120;
        NewColumn.pszText = calloc(100, sizeof(TCHAR));
        _swprintf(NewColumn.pszText, L"Column %u", Index);
        NewColumn.iSubItem = Index;
        ListView_InsertColumn(ListViewHandle, Index, &NewColumn);
    }

    bool ShouldQuit = false;
    while (ShouldQuit == false)
    {

        MSG Message;
        int Result = GetMessage(&Message, NULL, 0, 0);
        if (Result <= 0)
            return false;
        TranslateMessage(&Message);
        DispatchMessage(&Message);
    }
    return 0;
}

Este código me dá este resultado: que claramente tem alguns ids de subitens muito errados para essas linhas extras. O que estou fazendo errado?

Tenho um arquivo grande (gigabyte) onde uma expressão S aparece, e quero pular para o final da expressão S. A profundidade da expressão S é limitada a 2, então tentei usar uma expressão regular Python ( b'\\((?:[^()]|\\((?:[^()]|)*\\))*\\)'). Isso acabou consumindo muita RAM, e pesquisando mais a fundo descobri que o consumo de memória de expressões regulares moderadamente complexas parece altamente imprevisível se a correspondência for grande. Por exemplo, as quatro expressões regulares equivalentes a seguir correspondem a uma string completa de dez megabytes. A quarta (indiscutivelmente a mais complexa) usa uma quantidade razoável (30 M) de RAM, enquanto as outras consomem um gigabyte:

import re
dot = b'[' + b''.join(b'\\x%02x' % (c,) for c in range(256)) + b']'
assert re.match(b'(?:.|.)*', b'a'*10000000).end() > 1000000
assert re.match(b'(?:.|.|a)*', b'a'*10000000).end() > 1000000
assert re.match(b'(?:%s|%s)*' % (dot,dot), b'a'*10000000).end() > 1000000
assert re.match(b'(?:%s|%s|a)*' % (dot,dot), b'a'*10000000).end() > 1000000

(usando Python 3.12.3)

Existe uma maneira razoável de prever se o desempenho de uma regexp Python pode ser escalável? E, em particular, existem alguns princípios de design que eu possa seguir se quiser evitar armadilhas de desempenho?

(Esta pergunta é especificamente sobre o remódulo, porque prefiro usar bibliotecas Python padrão; suspeito que isso não seria um problema se eu mudasse para uma biblioteca de terceiros como regex)

Tenho várias imagens de animais no mesmo diretório do script. Como posso modificar o script a seguir para processar uma imagem, mas forçar a saída a ser apenas uma seleção única de uma lista:

from pathlib import Path
import base64
import requests

def encode_image_to_base64(image_path):
    """Convert an image file to base64 string."""
    return base64.b64encode(image_path.read_bytes()).decode('utf-8')

def extract_text_from_image(image_path):
    """Send image to local Llama API and get text description."""
    base64_image = encode_image_to_base64(image_path)

    payload = {
        "model": "llama3.2-vision",
        "stream": False,
        "messages": [
            {
                "role": "user",
                "content": (
                    "With just one word, classify this image into one of these exact categories:\n"
                    "- dog\n"
                    "- cat\n"
                    "- butterfly\n"
                ),
                "images": [base64_image]
            }
        ]
    }

    response = requests.post(
        "http://localhost:11434/api/chat",
        json=payload,
        headers={"Content-Type": "application/json"}
    )

    return response.json().get('message', {}).get('content', 'No text extracted')

def process_directory():
    """Process all images in current directory and create text files."""
    for image_path in Path('.').glob('*'):
        if image_path.suffix.lower() in {'.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp'}:
            print(f"\nProcessing {image_path}...")

            text = extract_text_from_image(image_path)
            image_path.with_suffix('.txt').write_text(text, encoding='utf-8')
            print(f"Created {image_path.with_suffix('.txt')}")

process_directory()

No entanto, apesar da engenharia de prompt diferente, recebo algumas respostas que farão mais do que apenas selecionar de uma lista. Por exemplo, pode ocasionalmente gerar " Da imagem, há um inseto alado, portanto meu palpite é "borboleta". RESPOSTA: Borboleta. " Se eu definir a lista como allowed_options = ['dog', 'cat', 'butterfly']eu quero que ela produza apenas uma única string dessa lista e nada mais.

Eu tenho um MyScript.scalaarquivo:

//> using scala "3"

object MyUtils {
  def sayHello() = println("Hello")
}

@main
def main(): Unit =
  MyUtils.sayHello();

Eu o executei com sucesso assim:

> scala MyScript.scala

Compiling project (Scala 3.6.4, JVM (17))
Compiled project (Scala 3.6.4, JVM (17))
Hello

Pergunta : O que preciso fazer para mover meu MyUtilsobjeto para outro arquivo de origem (por exemplo, MyUtils.scalaou MyUtils.sc) e ainda chamar o sayHellométodo de dentro MyScript.scala?

Sou novo no desenvolvimento WinUI, criei um novo aplicativo WinUI 3.0 simples (usando o modelo Blank App do Viusal Studio, empacotado (WinUI 3 no desktop )

Eu também instalei o seguinte

$ dotnet add package Serilog
$ dotnet add package Serilog.Sinks.Console
$ dotnet add package Serilog.Sinks.File

É assim que meu construtor App.xaml.cs se parece.

public App()
{
    this.InitializeComponent();

    Log.Logger = new LoggerConfiguration()
        .WriteTo.Console()
        .WriteTo.File("logs\\myapp.txt", rollingInterval: RollingInterval.Day)
        .CreateLogger();

    Log.Information("Application Starting");
}

Não vejo nenhum log no console ou arquivo sendo criado também. O que posso estar fazendo errado? Há alguma permissão especial que preciso solicitar etc. Agradeço qualquer dica ou sugestão de depuração para mim, obrigado.

É ideal testar uma visualização no Flutter ou é melhor testar apenas o widget, já que as visualizações geralmente dependem de muitas coisas no seu projeto?

Estou tentando testar uma visualização de login no flutter para melhorar minha cobertura de código e estou percebendo que a visualização em si depende de muitas coisas registradas dentro do GetIt. Há o NavigationService, o DialogService e alguns Usecase.