All perguntas(coding)

Atualmente, estou criando um aplicativo em python que usa a API de dados do YouTube e inclui o seguinte bloco de código:

import os
from subprocess import run
os.chdir(os.path.dirname(__file__))
command = 'python3.10 uploadYoutube.py --file="blank.mp4" --title="Blank" --description="THIS IS YOUR BLANK VIDEO" --keywords="blank" --category="20" --privacyStatus="private"'
terminal_output = run(command, capture_output=True).stdout 
print(terminal_output)

Isso produz o erro:

    terminal_output = run(command, capture_output=True).stdout
  File "C:\Program Files\WindowsApps\PythonSoftwareFoundation.Python.3.10_3.10.3056.0_x64__qbz5n2kfra8p0\lib\subprocess.py", line 503, in run
    with Popen(*popenargs, **kwargs) as process:
  File "C:\Program Files\WindowsApps\PythonSoftwareFoundation.Python.3.10_3.10.3056.0_x64__qbz5n2kfra8p0\lib\subprocess.py", line 971, in __init__
    self._execute_child(args, executable, preexec_fn, close_fds,
  File "C:\Program Files\WindowsApps\PythonSoftwareFoundation.Python.3.10_3.10.3056.0_x64__qbz5n2kfra8p0\lib\subprocess.py", line 1456, in _execute_child
    hp, ht, pid, tid = _winapi.CreateProcess(executable, args,
FileNotFoundError: [WinError 2] The system cannot find the file specified

Alguém sabe como posso corrigir esse erro?

Estou usando uma rota da API do Next.js App Router (app/api/notify/route.ts) para verificar a hora atual (no fuso horário do Brasil) e disparar notificações quando um horário agendado for atingido.

Isso funciona localmente, mas depois de implantar no Vercel, notei um comportamento inesperado:

❌ Problema: Após a primeira solicitação, todas as solicitações subsequentes retornam o mesmo registro de data e hora (tempo congelado desde a primeira execução), mesmo que eu esteja usando new Date() no manipulador.

Parece que a função está sendo armazenada em cache ou o ambiente está reutilizando o mesmo contexto.

✅ Comportamento esperado: toda vez que a rota for atingida, new Date() deve retornar a hora atual, refletindo o momento real da solicitação.

✅ Etapas reproduzíveis: implante este manipulador simples no Vercel.

Envie várias solicitações GET para o endpoint com alguns segundos/minutos de atraso.

Você notará que o timestamp e o isoTime nunca mudam após a primeira chamada.

import connectMongo from "@/libs/mongoose";
import Routine from "@/models/Routine";
import User from "@/models/User";
import PushSubscription from "@/models/PushSubscription";
const webPush = require("web-push");

const vapidPublicKey = process.env.NEXT_PUBLIC_WEB_PUSH_PUBLIC_KEY;
const vapidPrivateKey = process.env.WEB_PUSH_PRIVATE_KEY;

if (!vapidPublicKey || !vapidPrivateKey) {
    throw new Error("VAPID keys not configured");
}

console.log("VAPID keys configured correctly");
webPush.setVapidDetails("mailto:[email protected]", vapidPublicKey, vapidPrivateKey);

const getBrazilDateTime = () => {
    const now = new Date();
    const brazilTime = new Date(now.getTime() - 3 * 60 * 60 * 1000); // adjust for Brazil timezone
    return brazilTime;
};

const getDayNameInPortuguese = (date) => {
    const days = ["Domingo", "Segunda", "Terça", "Quarta", "Quinta", "Sexta", "Sábado"];
    return days[date.getDay()];
};

const getTaskStartTime = (task, currentDay) => {
    if (task.dailySchedule instanceof Map && task.dailySchedule.has(currentDay)) {
        const daySchedule = task.dailySchedule.get(currentDay);
        if (daySchedule && daySchedule.startTime) return daySchedule.startTime;
    } else if (task.dailySchedule && typeof task.dailySchedule === "object" && task.dailySchedule[currentDay]?.startTime) {
        return task.dailySchedule[currentDay].startTime;
    }
    if (task.startTime) return task.startTime;
    return null;
};

const deduplicateSubscriptions = (subscriptions) => {
    const uniqueEndpoints = new Set();
    return subscriptions.filter((sub) => {
        if (uniqueEndpoints.has(sub.endpoint)) return false;
        uniqueEndpoints.add(sub.endpoint);
        return true;
    });
};

const notifiedTasksCache = new Map();

const isTaskAlreadyNotified = (taskId, userId) => {
    const key = `${taskId}-${userId}`;
    const lastNotified = notifiedTasksCache.get(key);
    if (!lastNotified) return false;
    const tenMinutesAgo = Date.now() - 10 * 60 * 1000;
    return lastNotified > tenMinutesAgo;
};

const markTaskAsNotified = (taskId, userId) => {
    const key = `${taskId}-${userId}`;
    notifiedTasksCache.set(key, Date.now());
};

export async function GET(request) {
    const headers = new Headers({
        "Cache-Control": "no-store, max-age=0, must-revalidate",
        "Content-Type": "application/json",
    });

    const logs = [];
    const addLog = (message) => {
        console.log(message);
        logs.push(`[${new Date().toISOString()}] ${message}`);
    };

    addLog("🔔 Starting notification check...");
    addLog(`🕒 Start timestamp: ${Date.now()}`);

    try {
        addLog("Connecting to MongoDB...");
        await connectMongo();
        addLog("MongoDB connection established");

        // Update the time on each cycle to ensure the time is current.
        const spDate = getBrazilDateTime(); 
        const currentDay = getDayNameInPortuguese(spDate);
        const currentTime = spDate.toLocaleTimeString("pt-BR", {
            hour: "2-digit",
            minute: "2-digit",
            hour12: false,
        });

        addLog(`📅 Brazil date and time: ${spDate.toLocaleString("pt-BR")}`);
        addLog(`📅 Day of the week: ${currentDay}`);
        addLog(`⏰ Current time: ${currentTime}`);

        const users = await User.find({ activeRoutine: { $exists: true, $ne: null } });
        addLog(`👥 Found ${users.length} users with active routines`);

        if (!users.length) return NextResponse.json({ message: "No users with active routines found." });

        const routineIds = users.map((user) => user.activeRoutine).filter(Boolean);
        const routines = await Routine.find({ _id: { $in: routineIds } });
        const routineMap = new Map();
        routines.forEach((routine) => routineMap.set(routine._id.toString(), routine));

        let notificationsSent = 0;
        let usersNotified = 0;
        let duplicatesSkipped = 0;

        await Promise.all(
            users.map(async (user) => {
                const routineId = user.activeRoutine?.toString();
                if (!routineId) return;
                const routine = routineMap.get(routineId);
                if (!routine) return;

                const matchingTasks = routine.tasks.filter((task) => {
                    const taskDays = task.days || [];
                    const includesDay = taskDays.includes(currentDay);
                    const taskStartTime = getTaskStartTime(task, currentDay);
                    return includesDay && taskStartTime === currentTime;
                });

                if (!matchingTasks.length) return;

                for (const matchingTask of matchingTasks) {
                    if (isTaskAlreadyNotified(matchingTask._id.toString(), user._id.toString())) {
                        duplicatesSkipped++;
                        continue;
                    }

                    let subscriptions = await PushSubscription.find({ userId: user._id });
                    if (!subscriptions.length) continue;

                    subscriptions = deduplicateSubscriptions(subscriptions);
                    addLog(`  📱 User ${user.email} has ${subscriptions.length} unique devices`);

                    const payload = JSON.stringify({
                        title: `🔔 ${matchingTask.name} - Time to start!`,
                        body: `⏰ ${currentTime} - ${matchingTask.details || "Stay focused on your routine!"}`,
                        icon: "/icon512_rounded.png",
                        badge: "/icon192_rounded.png",
                        tag: `task-${matchingTask._id}`,
                        data: {
                            url: `/dashboard/r/${routine._id}`,
                            taskId: matchingTask._id.toString(),
                            type: "task-reminder",
                            timestamp: new Date().toISOString(),
                        },
                        actions: [
                            { action: "open", title: "📋 View Details" },
                            { action: "dismiss", title: "✔️ Got it" },
                        ],
                        vibrate: [200, 100, 200],
                        requireInteraction: true,
                    });

                    await Promise.all(
                        subscriptions.map(async (subscription) => {
                            try {
                                await webPush.sendNotification(
                                    {
                                        endpoint: subscription.endpoint,
                                        keys: subscription.keys,
                                    },
                                    payload
                                );
                                notificationsSent++;
                                markTaskAsNotified(matchingTask._id.toString(), user._id.toString());
                            } catch (error) {
                                if (error.statusCode === 410) {
                                    await PushSubscription.deleteOne({ _id: subscription._id });
                                }
                            }
                        })
                    );
                    usersNotified++;
                }
            })
        );

        return NextResponse.json(
            {
                message: `Notifications sent successfully!`,
                notificationsSent,
                usersNotified,
                duplicatesSkipped,
                logs,
            },
            { headers }
        );
    } catch (error) {
        console.error("Error sending notifications:", error);
        return NextResponse.json({ error: "Error processing notifications.", logs }, { status: 500, headers });
    }
}

🔍 O que tentei: removi toda a lógica externa — o manipulador mínimo acima ainda reproduz o problema.

Cabeçalhos de controle de cache Vercel: não parecem relacionados.

Foi verificado se uma variável global ou estática está retendo o estado — não é o caso.

❓ Minha pergunta: Este é um problema conhecido com o cache de funções ou comportamento de inicialização a frio do Vercel no Next.js App Router?

Como posso garantir que new Date() seja avaliado em todas as solicitações, não apenas na primeira?

As threads A, B e C realizam trabalhos separados (não é necessária sincronização entre elas). Assim que as três forem concluídas, a thread D combinará seus resultados. Portanto, D depende da conclusão de A, B e C.

int a = 0;
int b = 0;
int c = 0;
std::atomic_int D_dependencies{ 3 };

linha A:

a = 1;
D_dependencies.fetch_sub(1, std::memory_order_release);

linha B:

b = 1;
D_dependencies.fetch_sub(1, std::memory_order_release);

linha C:

c = 1;
D_dependencies.fetch_sub(1, std::memory_order_release);

linha D:

if(D_dependencies.load(std::memory_order_acquire) == 0)
{
    assert(a + b + c == 3);
}

Meu entendimento é que as operações RMW fetch_subformam uma "sequência de liberação" e, portanto, o carregamento na thread D deve observar todas as gravações se carregar 0 da variável atômica.
Estou correto?

Atualmente, estou construindo uma CLI usando o Pydantic . Um dos subcomandos tem 2 parâmetros que eu gostaria de carregar por meio de uma variável de ambiente. Consegui carregar as variáveis ​​de ambiente por conta própria quando instanciei a classe diretamente, mas agora que ela é uma variável de ambiente CliSubCommand, estou com problemas para carregar os dois parâmetros por meio de variáveis ​​de ambiente. Também consegui fazer a CLI funcionar quando AWSStsGcpa classe estava herdando de BaseModel, fornecendo-a por meio da linha de comando. O Pydantic está apresentando um erro informando que as duas flags da AWS são necessárias. Elas estão localizadas no modelo aws_sts_gcp.py -> aws_access_keye aws_secret_key.

Também não quero que seja uma configuração global obrigatória, já que atualmente ela só é relevante para um comando.

root_tool.py

    from pydantic import BaseModel
    from pydantic_settings import CliSubCommand, CliApp
    from python_tools.gcp.models.aws_sts_gcp import AwsStsGcp
    
    class DummyCommand(BaseModel):
        project_id: str
    
        def cli_cmd(self) -> None:
            print(f'This is a dummy command.{self.project_id}"')
        
    class Tool(BaseModel):
        aws_sts: CliSubCommand[AwsStsGcp]
        dummy: CliSubCommand[DummyCommand]
    
        def cli_cmd(self) -> None:
            CliApp.run_subcommand(self)

aws_sts_gcp.py

    from pydantic import SecretStr
    from pydantic_settings import BaseSettings, SettingsConfigDict
    
    from python_tools.gcp.aws_gcs_transfer import create_aws_transfer_job 
    
    class AwsStsGcp(BaseSettings, cli_parse_args=True):
        model_config = SettingsConfigDict(env_file='.env', env_file_encoding='utf-8')
        destination_bucket: str
        src_bucket: str
        manifest_path: str | None = None
        aws_access_key: SecretStr
        aws_secret_key: SecretStr
        tranfer_name: str
        project_id: str
    
        def cli_cmd(self) -> None:
            create_aws_transfer_job(self)

cli_runner.py

from python_tools.gcp.models.root_tool import Tool
from pydantic_settings import CliApp

CliApp.run(Tool)

aws_gcs_transfer.py

from google.cloud.storage_transfer_v1 import (
    StorageTransferServiceClient,
    TransferJob,
    TransferSpec,
    TransferManifest,
    AwsS3Data,
    AwsAccessKey,
    GcsData,
    RunTransferJobRequest,
    CreateTransferJobRequest
)
#from python_tools.gcp.models.aws_sts_gcp import AwsStsGcp
from python_tools.consts import timestr
from python_tools.logging import logger

import time

def create_aws_transfer_job(transfer_details) -> None:
    s3_config = None

    transfer_manifest = None 

    client = StorageTransferServiceClient()
    s3_config = AwsS3Data(
        bucket_name=transfer_details.src_bucket,
        aws_access_key=AwsAccessKey(
            access_key_id=transfer_details.aws_access_key.get_secret_value(), secret_access_key=transfer_details.aws_secret_key.get_secret_value()
        )
    )

    gcs_dest = GcsData(bucket_name=transfer_details.destination_bucket)

    if transfer_details.manifest_path is not None:
        transfer_manifest = TransferManifest(location=transfer_details.manifest_path)
    
    sts_spec = TransferSpec(gcs_data_sink=gcs_dest, aws_s3_data_source=s3_config, transfer_manifest=transfer_manifest)
    timestamp = time.strftime(timestr)
    name = f"transferJobs/{transfer_details.tranfer_name}-{timestamp}"
    description = "Automated STS Job created from Python Tools."
    sts_job = TransferJob(
        project_id=transfer_details.project_id,
        name=name,
        description=description,
        transfer_spec=sts_spec,
        status=TransferJob.Status.ENABLED,
    )
    job_request = CreateTransferJobRequest(transfer_job=sts_job)

    logger.info(f"Starting Transfer Job for Job ID: {name}")
    transfer_request = RunTransferJobRequest(project_id=transfer_details.project_id, job_name=name)

    client.create_transfer_job(request=job_request)
    client.run_transfer_job(request=transfer_request)

.env

AWS_ACCESS_KEY = "test"
AWS_SECRET_KEY = "test"

Também tentei usar BaseSettings na raiz assim.

from pydantic import BaseModel
from pydantic_settings import CliSubCommand, CliApp, BaseSettings, SettingsConfigDict

from python_tools.gcp.models.aws_sts_gcp import AwsStsGcp

class DummyCommand(BaseModel):
    project_id: str

    def cli_cmd(self) -> None:
        print(f'This is a dummy command.{self.project_id}"')
    
class Tool(BaseSettings, cli_parse_args=True):
    model_config = SettingsConfigDict(env_file='.env', env_file_encoding='utf-8', extra='ignore')

    aws_sts: CliSubCommand[AwsStsGcp]
    dummy: CliSubCommand[DummyCommand]

    def cli_cmd(self) -> None:
        CliApp.run_subcommand(self)

from pydantic import SecretStr, BaseModel, Field  
from python_tools.gcp.aws_gcs_transfer import create_aws_transfer_job 

class AwsStsGcp(BaseModel):
    destination_bucket: str
    src_bucket: str
    manifest_path: str | None = None
    aws_access_key: SecretStr = Field(alias='AWS_ACCESS_KEY', env="AWS_ACCESS_KEY")
    aws_secret_key: SecretStr = Field(alias='AWS_SECRET_KEY',  env="AWS_SECRET_KEY")
    tranfer_name: str
    project_id: str

    def cli_cmd(self) -> None:
        create_aws_transfer_job(self)

Tenho o trecho de código abaixo que estou tentando substituir por vários motivos.

$SubscriptionPIMID = (Get-AzureADMSPrivilegedResource -ProviderId 'AzureResources' -Filter "ExternalId eq '/subscriptions/$subscriptionId'").Id

O acima exige o uso do módulo AzureAdPreview, do qual estou tentando me afastar. Em segundo lugar, ao executar a partir da automação, ele requer que o Connect-AzureAD seja executado, o que está se mostrando difícil de automatizar. Além disso, minha preferência é usar o Graph.

Eu tentei o seguinte.

Connect-MgGraph -Scopes "PrivilegedAccess.Read.AzureResources"

# Set the subscription ID
$subscriptionId = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"

# Get the PIM resource for that subscription
$pimResource = Get-MgPrivilegedAccessResource `
    -ProviderId "AzureResources" `
    -Filter "externalId eq '/subscriptions/$subscriptionId'"

# Output the resource ID
$pimResource.Id

Parece que também não funciona, pois recebo o erro Get-MgPrivilegedAccessResource: The term 'Get-MgPrivilegedAccessResource' is not recognized as a name of a cmdlet, function, script file, or executable program. Check the spelling of the name, or if a path was included, verify that the path is correct and try again.mesmo depois de instalar o módulo e importar o módulo gráfico.

Estou aprendendo GraphQL e tentando configurar o Apollo Server com Express (v4), mas continuo recebendo o seguinte erro ao fazer uma solicitação para /graphql:

req.body is not set; this probably means you forgot to set up the `json` middleware before the Apollo Server middleware.

Aqui está o código do meu servidor:

const express = require("express");
const { ApolloServer } = require('@apollo/server');
const { expressMiddleware } = require('@apollo/server/express4')
const cors = require('cors');

async function startServer() {
    const app = express();

    const server = new ApolloServer({
        typeDefs: `
            type Todo {
                id: ID!
                title: String!
                completed: Boolean!
            }
            
            type Query {
                getTodos: [Todo]
            }
        `,
        resolvers: {
            Query: {
                getTodos: () => []
            }
        }
    });

    await server.start();

    app.use('/graphql', cors(), express.json(), expressMiddleware(server));

    const PORT = process.env.PORT || 8000;
    await new Promise((resolve) => app.listen(PORT, resolve));
    console.log(`Server is running on port ${PORT}`);
}

startServer().catch((err) => {
    console.error('Error starting the server:', err);
});

Adicionei express.json() antes do expressMiddleware, mas o erro persiste. Há algo que estou esquecendo ao usar o Apollo Server com o middleware Express 4?

Qualquer ajuda é bem-vinda!

Estou me aprofundando na compreensão de reflexão e indicadores e me deparei com um desafio interessante. Digamos que você tenha a seguinte turma:

namespace Foobar
{
    internal class Foo()
    {
        internal static readonly Me = new Foo();
    }
}

Posso obter facilmente o valor do campo usando isto:

Assembly a = Assembly.Load("AssemblyWithFoo");
Type t = a.GetType("Foobar.Foo");
FieldInfo fi = t.GetRuntimeFields().First(f => f is { Name: "Me", IsStatic: true });
var bar = fi.GetValue(null);

Mas definir um novo valor nisso não é permitido porque readonly"Code Access Security" está obsoleto.

fi.SetValue(null, new Foo());

Então eu estava pensando em usar ponteiros unsafepara alterar esse campo:

var foo = GetFooFromAssembly();
var bar = fi.GetValue(null);
unsafe
{
    object* ptr = &bar;
    *ptr = foo;
}

Isso funciona porque altera a barvariável para conter foo, mas não altera o campo porque a barvariável é uma "cópia" do campo estático, não o campo em si.

Existe uma maneira de obter o ponteiro para o campo somente leitura estático e definir um novo objeto nele?

Sou novo no CoreData, mas criei um objeto que pretendo usar como uma matriz dentro de um loop ForEach no SwiftUI.

No editor de entidades, adicionei um atributo UUID stored_id. Em seguida, em uma extensão, escrevi isto:

extension Item: Identifiable {
    public var id: UUID {
        guard let stored_id else {
            assertionFailure("No stored ID")
            return UUID()
        }
        return stored_id
    }
    
}

Isso me parece bastante estranho por vários motivos, como o fato de stored_id ser opcional dada a semântica do CoreDatas. Será que isso é uma prática ruim por algum motivo?

Preciso da sua ajuda para alterar o fundo e o preenchimento lateral deste código gráfico. Como posso fazer isso no formato de exemplo da imagem?

Set EMAChart = Sheets("Parameters").ChartObjects.Add(Left:=Range("a18").Left, Width:=700, Top:=Range("a18").Top, Height:=500)
With EMAChart.Chart
   'EMA_A Grafik
    .Parent.Name = "EMA Chart"

    With .SeriesCollection.NewSeries
        .ChartType = xlLine
        .Values = Sheets("data").Range("e2:e" & numRows)
        .XValues = Sheets("data").Range("a2:a" & numRows)
        .Format.Line.Weight = 1
        .Border.ColorIndex = 1
        .Name = "Price"
    End With

    With .SeriesCollection.NewSeries
        .ChartType = xlLine
        .AxisGroup = xlPrimary
        .Values = Sheets("data").Range("h2:h" & numRows)
        .Name = "EMA_A"
        .Border.ColorIndex = 44
        .Format.Line.Weight = 1

    End With
    'EMA_B Grafik
    With .SeriesCollection.NewSeries
        .ChartType = xlLine
        .AxisGroup = xlPrimary
        .Values = Sheets("data").Range("ı2:ı" & numRows)
        .Name = "EMA_B"
        .Border.ColorIndex = 26
        .Format.Line.Weight = 1

    End With
    'EMA_c Grafik
    With .SeriesCollection.NewSeries
        .ChartType = xlLine
        .AxisGroup = xlPrimary
        .Values = Sheets("data").Range("j2:j" & numRows)
        .Name = "EMA_C"
        .Border.ColorIndex = 17
        .Format.Line.Weight = 1

    End With
    .Axes(xlValue, xlPrimary).HasTitle = True
    .Axes(xlValue, xlPrimary).AxisTitle.Characters.Text = "Price"
    .Axes(xlValue, xlPrimary).MaximumScale = WorksheetFunction.Max(Sheets("Data").Range("e2:e" & numRows))
    .Axes(xlValue, xlPrimary).MinimumScale = Int(WorksheetFunction.Min(Sheets("Data").Range("e2:e" & numRows)))
    .Legend.Position = xlLegendPositionBottom
    .SetElement (msoElementChartTitleAboveChart)
    .ChartTitle.Text = " "

End With

Ainda sou muito novo em TypeScript. Trabalhando em um projeto Next.js, estou exibindo uma lista de itens agrupados com títulos. Se não houver itens no grupo que atendam a um critério específico, não quero exibir o título ou os itens. Já usei a Array.any()função Kotlin antes como uma forma de dizer "se algum item corresponder a esse critério, inclua-o". Não encontrei uma maneira de fazer isso diretamente em TypeScript. No exemplo abaixo, gostaria de manter a Itemlista se algum de seus itens tiver um someProp = null. A única maneira que encontrei de fazer isso, até agora, é usando, !Array.every()mas a dupla negativa "nem todo item.someProp é nulo" é realmente pesada na complexidade cognitiva. Existe uma maneira melhor de fazer isso?

{Object.entries(groupedListData!)
  .filter(
    ([key, itemsGroupedByKey]) =>
      !itemsGroupedByKey.every(
        (item) => item.someProp !== null
      )
    )
  ...

Li todas as funções de Array e nenhuma delas parece se encaixar perfeitamente. Também li sobre estender a classe interna Array com a minha própria, any()mas isso me parece um pouco pesado. Não precisarei disso para mais do que alguns pontos no código.