Perguntas[python](coding)

Olá... estou tentando adicionar um parâmetro à minha consulta, mas recebo este erro:

"errorMessage": "{'S': 'ERROR', 'V': 'ERROR', 'C': '42601', 'M': 'syntax error at or near \”$2\"', 'P': '3793', 'F': 'scan.l', 'L': '1146', 'R': 'scanner_yyerror'}"

Isso funciona:

import pg8000

account_id = 1234

sql = “”"
    SELECT *
    FROM samples
    WHERE account_id = %s
    AND delete_date IS NULL
    ORDER BY date DESC
“”"

cursor.execute(sql, (account_id,))

Mas isso não:

import pg8000

account_id = 1234

start_date = query_string_params['start-date'] if 'start-date' in query_string_params else None

// start_date format is: '2025-02-04'

filters = “"
if start_date is not None:
   filters = filters + f" AND DATE(sample_date) >= '{start_date}'"

sql = “”"
    SELECT *
    FROM samples
    WHERE account_id = %s
    AND delete_date IS NULL
    %s
    ORDER BY date DESC
“”"

cursor.execute(sql, (account_id, filters))

Alguém tem ideia do que estou fazendo errado?

Eu tenho este exemplo de Polars DataFrame:

import polars as pl 

df = pl.DataFrame({
    "id": [1, 2, 3, 4, 5],
    "variable1": [15, None, 5, 10, 20],
    "variable2": [40, 30, 50, 10, None],
}) 

Estou tentando filtrar todas as colunas do meu dataframe usando o método pl.all(), e também tentei usar pl.any_horizontal() == Condition. No entanto, estou recebendo o seguinte erro:

ComputeError: The predicate passed to 'LazyFrame.filter' expanded to multiple expressions: 

    col("id").is_not_null(),
    col("variable1").is_not_null(),
    col("variable2").is_not_null(),
This is ambiguous. Try to combine the predicates with the 'all' or `any' expression.

Aqui estão minhas tentativas de enfrentar isso.

# Attempt 1:
(
    df
    .filter(
        pl.all().is_not_null()
    )
)
# Attempt 2:
(
    df
    .filter(
        pl.any_horizontal().is_not_null()
    )
)

Saída desejada, mas não é escalável para DataFrames maiores:

(
    df
    .filter(
        pl.col("variable1").is_not_null(),
        pl.col("variable2").is_not_null()
    )
)

Como posso filtrar todas as colunas de forma escalável sem especificar cada coluna individualmente?

Tenho um script para meu USB que preciso usar em vários dispositivos e quero que ele seja ejetado automaticamente. Usando esse método, desde que tenha privilégios elevados, ele roda sem problemas, sem erros, mas verifico o explorador de arquivos e o USB ainda está lá:

            p = Popen(["diskpart"], stdin=PIPE)
            p.stdin.write(b"select disk " + drive_letter.encode() + b"\n")
            p.stdin.write(b"remove all dismount\n")
            p.stdin.write(b"exit\n")
            print(f"Successfully ejected drive {successful_drive_path}.")

Tudo isso usando o módulo subprocess para Python. Sei que não preciso fazer isso, mas ainda quero fazer. Suspeito que seja devido ao código estar sendo executado no USB, então talvez eu pudesse, com o arquivo bat que uso para executar e gerenciar tudo, executar o código de ejeção usando um script de autoexclusão no disco principal. Não sei, só tenho ideias.

Estou trabalhando em uma tarefa em Python, na qual só consigo fatiar usando o :método slice (por exemplo, group= strg [:index]). Por algum motivo, o método slice se recusa a reconhecer qualquer coisa com mais de 2 dígitos quando se trata de números. Palavras funcionam bem, mas dígitos estão sendo cortados.

Aqui está meu código:

import sys 

# set up for for loop
length = len(sys.argv)

for i in range(1, length):
   strg = sys.argv[i]
   #finds name
   index = strg.find(':')
   name  = strg[:index]
   strg  = strg[index+1:]
   
   index = strg.find(',')
   total  = 0
   count  = 0
   while (index != -1):
       group = strg[:index]
       try:
           num = int(group)
       except:
           break
       else:       
           print(num)    
           total = total+num
           count = count+1
           strg = strg[index+1:]
       
   print(count)
   avg = total/count
   print(name+", average:", avg)

Entrada:Neda:90,80,70,90,50 John:80,100,30 Mary:20,100,90,80

Minha saída:

90
80
70
90
50
5
Neda, average: 76.0
80
10
2
John, average: 45.0
20
10
2
Mary, average: 15.0

Saída pretendida:

90
80
70
90
50
5
Neda, average: 76.0
80
100
30
3
John, average: 70.0
20
100
90
80
4
Mary, average: 72.5

Eu tenho este script simples:

import os
import gradio as gr
from fastapi import FastAPI, Request
import uvicorn
import threading
from typing import List
from datetime import datetime

api = FastAPI()

# Shared logs

class Log():
    def __init__(self):
        self._logs: List[str] = []
        self.logstr=""
    
    def log_message(self,msg: str):
        timestamp = datetime.now().strftime("%H:%M:%S")
        self._logs.append(f"[{timestamp}] {msg}")
        self.logstr="\n".join(self._logs)


log = Log()
log_state=gr.State(log)

# === FastAPI Setup ===


@api.post("/log")
async def receive_log(request: Request):
    data = await request.body()
    msg = f"API received: {data}"
    log.log_message(msg)
    gr.update(value=log.logstr)
    return {"status": "logged", "message": msg}

def run_api():
    api_port = int(os.environ.get("API_PORT", 8000))
    uvicorn.run(api, host="0.0.0.0", port=api_port)

# === Gradio UI ===

with gr.Blocks() as ui:
    gr.Markdown("## 📝 Incoming HTTP Requests")
    log_box = gr.Textbox(label="Logs", inputs=log_state, lines=20)
    
    # Trigger the refresh when the log state is updated


def run_gradio():
    gradio_port = int(os.environ.get("GRADIO_PORT", 7860))
    ui.launch(server_port=gradio_port)

# === Start Both ===
if __name__ == "__main__":
    threading.Thread(target=run_api, daemon=True).start()
    run_gradio()

O que tento fazer é ter o FastAPI escutando uma porta e um painel que exibe em tempo real as solicitações recebidas:

POST /log -> FastAPI ->common_log -> Gradio

Mas não consigo alterar o conteúdo Textboxquando recebo solicitações de entrada no FastAPI. Como posso fazer isso?

Estou preso a cargas unidas em vários modelos. Tenho um projeto FastAPI e estou usando Jinja para servir algumas páginas HTML. Nessa página, preciso acessar o conteúdo unido de outras tabelas (parece que fazer o acesso no momento de não funciona no modelo Jinja? Continuo recebendo erros do Greenlet). Como certamente obterei esses dados, estou fazendo cargas unidas nas propriedades que mapeiam para os outros modelos:

statement = statement.options(
    joinedload(Item.purchases),
    joinedload(Item.purchases.receipt),
    joinedload(Item.purchases.receipt.store),
)

No entanto, recebo este erro:

    joinedload(Item.purchases.receipt),
               ^^^^^^^^^^^^^^^^^^^^^^
  File "/app/.venv/lib/python3.12/site-packages/sqlalchemy/orm/attributes.py", line 474, in __getattr__
    raise AttributeError(
AttributeError: Neither 'InstrumentedAttribute' object nor 'Comparator' object associated with Item.purchases has an attribute 'receipt'

Além disso, como estou unindo 4 tabelas, sinto que devo minimizar o número de colunas selecionadas nas junções, mas não sei como faria isso.

Estou tentando criar um gráfico de barras empilhadas de duas barras usando o Plotly.

Encontrei este código:

from plotly import graph_objects as go

data = {
    "original":[15, 23, 32, 10, 23],
    "model_1": [4,   8, 18,  6,  0],
    "model_2": [11, 18, 18,  0,  20],
    "labels": [
        "feature",
        "question",
        "bug",
        "documentation",
        "maintenance"
    ]
}

fig = go.Figure(
    data=[
        go.Bar(
            name="Original",
            x=data["labels"],
            y=data["original"],
            offsetgroup=0,
        ),
        go.Bar(
            name="Model 1",
            x=data["labels"],
            y=data["model_1"],
            offsetgroup=1,
        ),
        go.Bar(
            name="Model 2",
            x=data["labels"],
            y=data["model_2"],
            offsetgroup=1,
            base=data["model_1"],
        )
    ],
    layout=go.Layout(
        title="Issue Types - Original and Models",
        yaxis_title="Number of Issues"
    )
)

Fonte: https://dev.to/fronkan/stacked-and-grouped-bar-charts-using-plotly-python-a4p

Isso funciona, mas preciso ir um passo além, se possível. Preciso que os vários modelos apareçam em ambos os lados de cada conjunto de barras, pois estou adicionando outro parâmetro (sim à esquerda e não à direita). No exemplo, o azul está sempre na barra da esquerda e o laranja e/ou verde estão sempre à direita. Estou procurando uma maneira de fazer com que qualquer uma dessas cores possa aparecer tanto à esquerda quanto à direita de um conjunto de barras, mas com valores diferentes. Por exemplo, no exemplo, o recurso tem uma contagem de barras azuis de 15, mas talvez no lado direito do recurso o azul tenha um valor de 5.

Estou tentando atribuir uma variável a uma instância de uma classe de forma que a variável seja do mesmo tipo. Quero usar a própria instância na construção da variável. Para ser compatível com herança, quero usar a sugestão de tipo como, Selfem vez da classe.

As seguintes obras:

class Foo:

    var: "Foo"

    def bar(self) -> None:
        self.var = self

No entanto, varestá marcado como sendo do tipo , Fooem vez de Self. O que eu quero é:

from typing import Self

class Foo:

    var: Self

    def bar(self) -> None:
        self.var = self

Neste caso, o mypy me dá a seguinte mensagem:

error: Incompatible types in assignment (expression has type "Foo", variable has type "Self")  [assignment]

Claramente, selfnão é considerado como sendo do tipo, Selfmas somente do tipo Foo.

Estou tentando fazer uma exibição do conjunto de Mandelbrot, com o seguinte código:

import numpy as np
import matplotlib.pyplot as plt

plt.rcParams['toolbar'] = 'None'

def mandelbrot(c, max_iter):
    z = 0
    for n in range(max_iter):
        if abs(z) > 2:
            return n
        z = z*z + c
    return max_iter

def mandelbrot_set(xmin, xmax, ymin, ymax, width, height, max_iter):
    r1 = np.linspace(xmin, xmax, width)
    r2 = np.linspace(ymin, ymax, height)
    n3 = np.empty((width, height))

    for i in range(width):
        for j in range(height):
            n3[i, j] = mandelbrot(r1[i] + 1j*r2[j], max_iter)
    return n3.T

# Settings
xmin, xmax, ymin, ymax = -2.0, 1.0, -1.5, 1.5
width, height = 800, 800
max_iter = 256

# Generate Mandelbrot set
mandelbrot_image = mandelbrot_set(xmin, xmax, ymin, ymax, width, height, max_iter)

# Window
fig = plt.figure(figsize=(5, 5))
fig.canvas.manager.set_window_title('Mandelbrot Set')
ax = fig.add_axes([0, 0, 1, 1])   # Fill the whole window
ax.set_axis_off()

# Show fractal
ax.imshow(mandelbrot_image, extent=(xmin, xmax, ymin, ymax), cmap='hot')
plt.show()

Como posso ampliar o fractal continuamente, sem consumir muitos recursos? Estou usando um laptop de médio porte e, atualmente, a geração do fractal demora muito. Existe uma maneira mais rápida de fazer isso ao implementar um recurso de zoom?

Tenho uma janela em tela cheia com uma tela em tela cheia. Primeiro, coloco uma imagem de fundo em tela cheia nessa tela.

canvas = tk.Canvas(window, bg="white", bd=0)
canvas.pack(fill=tk.BOTH, expand=True)
canvas.update()

image = Image.open('bild.jpg')
newimage = image.resize((canvas.winfo_width(),canvas.winfo_height()),Image.LANCZOS)
photo = ImageTk.PhotoImage(newimage, master=canvas)
canvas.create_image(0, 0, anchor="nw", image=photo)
canvas.update()

Em seguida, coloco um texto de título no canto superior direito e, abaixo dele, um texto mais longo. O texto é muito mais longo do que a altura da tela.

rectangle_width = int(canvas.winfo_width() * 0.45)
rectangle_x     = canvas.winfo_width() - rectangle_width

headblock = canvas.create_text(
    rectangle_x+10, 10,
    anchor='nw',
    text=headline,
    font=('Helvetica', 18, 'bold'),
    fill='black',
    width=rectangle_width - 20
)
x1, y1, x2, y2 = canvas.bbox(headblock)
textblock = canvas.create_text(
    rectangle_x+10, y2+10,
    anchor='nw',
    text=fulltext,
    font=('Helvetica', 14, 'normal'),
    fill='black',
    width=rectangle_width - 20
)
canvas.update()

Agora, quero animar o texto longo, como um telepromter, movendo-o lentamente para cima, para que os espectadores possam ler o texto completo. Isso funciona bem com canvas.move().

def animate():
    canvas.move(textblock, 0, -1)
    x1, y1, x2, y2 = canvas.bbox(textblock)
    if y2 > canvas.winfo_height():
        window.after(60, animate)

Mas enquanto o bloco de texto sobe, ele é exibido atrás do título. O problema é a imagem de fundo. Ela deveria estar sempre visível. Se eu colocar o título e o texto em objetos diferentes, rótulos, telas, etc., eles não ficam mais transparentes.

Alguém tem uma boa ideia de como mover apenas o texto longo, enquanto a imagem está sempre visível e o título permanece estático?