iBeMeltin's questions

Tenho um fluxo que é responsável por criar/atualizar uma lista do sharepoint com arquivos de um e-mail.

Basicamente, o fluxo é executado quando um e-mail chega, eu verifico o dia e a hora em que o e-mail chega e adiciono o arquivo a uma lista do SharePoint com base no dia e na hora.

Preciso que a lista do sharepoint tenha apenas certos arquivos em um determinado momento. Por exemplo:

Any email that arrives between Friday 6pm - Monday 9am need to be put in the same list
Any email that arrives between Monday 6pm - Tuesday 9am need to be put in the same list
Any email that arrives between Tuesday 6pm - Wednesday 9am need to be put in the same list
Any email that arrives between Wednesday 6pm - Thursday 9am need to be put in the same list
Any email that arrives between Thursday 6pm - Friday 9am need to be put in the same list

No entanto, estou tendo um problema ao construir a condição. Aqui estão as expressões que uso para obter o dia e a hora:

int(formatDateTime(triggerOutputs()?['body/receivedDateTime'], 'HH'))

dayOfWeek(triggerOutputs()?['body/receivedDateTime'])

Como eu elaboraria minha condição?

Tenho as seguintes tabelas:

Tabela de contraparte

Counterparty
foo 
boo
fizz
buzz
huzz

Tabela 1 Dados:

Counterparty Commodity DealType   StartDate  FloatPrice  MTMValue
      foo       bar      Buy  07/01/2024       18.73        10
      fizz      bar      Buy  09/01/2024       17.12        10
      fizz      bar      Buy  10/01/2024       17.76        10
      fizz      bar      Buy  11/01/2024       18.72        10
      fizz      bar      Buy  12/01/2024       19.47        10
      foo   ab cred      Buy  01/01/2025       20.26        10
      boo       baz     Sell  01/01/2025       21.04        10
      boo       baz     Sell  01/01/2025       22.23        10
      fizz      baz     Sell  01/01/2025       11.89        10
      fizz      baz     Sell  01/01/2025       12.33        10
      foo       baz     Sell  01/01/2025       14.78        10
      foo       baz     Sell  01/01/2025       18.23        10
      boo      rins     Sell  01/01/2025       16.43        10
      boo   ab cred     Sell  01/01/2025       12.21        10

Tabela 2 Dados

Counterparty Commodity DealType   StartDate  FloatPrice  MTMValue
      foo       bar      Buy  07/01/2024       18.73        10
      fizz      bar      Buy  09/01/2024       17.12        10
      fizz      bar      Buy  10/01/2024       17.76        10
      fizz      bar      Buy  11/01/2024       18.72        10
      fizz      bar      Buy  12/01/2024       19.47        10
      foo   ab cred      Buy  01/01/2025       20.26        10
      boo       baz     Sell  01/01/2025       21.04        10
      boo       baz     Sell  01/01/2025       22.23        10
      fizz      baz     Sell  01/01/2025       11.89        10
      fizz      baz     Sell  01/01/2025       12.33        10
      foo       baz     Sell  01/01/2025       14.78        10
      foo       baz     Sell  01/01/2025       18.23        10
      boo      rins     Sell  01/01/2025       16.43        10
      boo   ab cred     Sell  01/01/2025       12.21        10

Para efeito de exemplo, table1 e table2 são exatamente idênticas. Na prática, elas são estruturadas de forma idêntica, mas têm valores diferentes nas últimas colunas.

Como posso escrever uma consulta para criar uma tabela como a seguinte com base nessas 3 tabelas:

PARA MERCADORIA = BARRA

Counterparty  Table1 Sum  Table2 Sum
   foo            10          10
   boo            0           0
   fizz           40          40
   buzz           0           0
   huzz           0           0       

Terei um fatiador acoplado à mesa para filtrar entre as commodities

Estou recebendo um erro ao tentar aplicar uma cor a colunas específicas ao criar uma tabela com o reportlab.

Aqui está meu script completo para um exemplo reproduzível (você precisará colocar um caminho de saída na linha 109):

import pandas as pd
from datetime import datetime
from reportlab.platypus import Frame
from reportlab.lib.pagesizes import A4, landscape
from reportlab.platypus import PageTemplate
from reportlab.platypus import BaseDocTemplate
from reportlab.platypus import Image
from reportlab.lib.units import inch
from reportlab.platypus import Table, Paragraph
from reportlab.lib import colors
from reportlab.platypus import NextPageTemplate, PageBreak
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle

def on_page(canvas, doc, pagesize=A4):
    page_num = canvas.getPageNumber()
    canvas.drawCentredString(pagesize[0]/2, 50, str(page_num))

    now = datetime.now()
    today = now.strftime("%B %d, %Y")  
    current_time = now.strftime("%I:%M %p") 

    canvas.drawString(50, pagesize[1] - 50, f"{today}")
    canvas.drawString(50, pagesize[1] - 70, f"{current_time}") 

def on_page_landscape(canvas, doc):

  return on_page(canvas, doc, pagesize=landscape(A4))

def format_nums(num):
    if num < 0: 
       x = '(${:.2f})'.format(abs(num))
    elif num > 0:
        x = '${:.2f}'.format(num)
    else:
       x = '${:.0f}'.format(num)

    return x

def df2table(df, custom_style):
    for col in df.columns:
        if df[col].dtype == 'float64':
            df[col] = df[col].apply(lambda x: format_nums(x)) 

    #('BACKGROUND', (start_col, start_row), (end_col, end_row), color)
    return Table(
        [[Paragraph(col, custom_style) for col in df.columns]] + df.values.tolist(),
        style = [
        ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),  # Header font
        ('FONTSIZE', (0, 1), (-1, -1), 8),  # Body font size
        ('TEXTCOLOR', (0, 0), (-1, 0), colors.white),  # Header text color
        ('BACKGROUND', (0, 0), (-1, 0), colors.lightgrey),  # Header background color
        ('BACKGROUND', (0, 0), (0, 0), colors.lightblue),  # first Header background color
        ('BACKGROUND', (0, 1), (0, -1), colors.lightblue),  # First column background color
        ('LINEBELOW', (0, 0), (-1, 0), 1, colors.black),  # Line below header
        ('INNERGRID', (0, 0), (-1, -1), 0.25, colors.black),  # Inner grid lines
        ('BOX', (0, 0), (-1, -1), 1, colors.black)],  # Outer box
        hAlign = 'LEFT')

def df2table2(df, custom_style, commodity_cols):
    for col in df.columns:
        if df[col].dtype == 'float64':
            df[col] = df[col].apply(lambda x: format_nums(x))

    data = [[Paragraph(col, custom_style) for col in df.columns]] + df.values.tolist()
    
    #('BACKGROUND', (start_col, start_row), (end_col, end_row), color)
    style = [
        ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),  # Header font
        ('FONTSIZE', (0, 1), (-1, -1), 8),  # Body font size
        ('TEXTCOLOR', (0, 0), (-1, 0), colors.white),  # Header text color
        ('BACKGROUND', (0, 0), (-1, 0), colors.lightgrey),  # Header background color
        ('LINEBELOW', (0, 0), (-1, 0), 1, colors.black),  # Line below header
        ('INNERGRID', (0, 0), (-1, -1), 0.25, colors.black),  # Inner grid lines
        ('BOX', (0, 0), (-1, -1), 1, colors.black)]  # Outer box
    
    # Apply colors based on column types
    for i, col in enumerate(df.columns): 
        if col in commodity_cols:
            style.append(('BACKGROUND', (i, 1), (i, -1), colors.lightgrey))  # Commodity column
        else:
            if col != 'Counterparty':
                style.append(('BACKGROUND', (i, 1), (i, -1), colors.lightgreen))  # Aggregation column

    return Table(data, style, hAlign='LEFT')

df = pd.DataFrame({
        'Counterparty': ['foo', 'fizz', 'fizz', 'fizz','fizz', 'foo'],
        'Commodity': ['bar', 'bar', 'bar', 'bar','bar', 'ab cred'],
        'DealType': ['Buy', 'Buy', 'Buy', 'Buy', 'Buy', 'Buy'],
        'StartDate': ['07/01/2024', '09/01/2024', '10/01/2024', '11/01/2024', '12/01/2024', '01/01/2025'],
        'FloatPrice': [18.73, 17.12, 17.76, 18.72, 19.47, 20.26],
        'MTMValue':[10, 10, 10, 10, 10, 10]
        })

commodity_cols = df['Commodity'].unique()

out = pd.pivot_table(df, values = 'MTMValue', index='Counterparty', columns = 'Commodity', aggfunc='sum').reset_index().rename_axis(None, axis=1).fillna(0)
out['Cumulative Exposure'] = out[out.columns[1:]].sum(axis = 1)

path = <INSERT PDF OUTPUT FILE HERE>

padding = dict(
    leftPadding=72, 
    rightPadding=72,
    topPadding=72,
    bottomPadding=18)

portrait_frame = Frame(0, 0, *A4, **padding)
landscape_frame = Frame(0, 0, *landscape(A4), **padding)
            
portrait_template = PageTemplate(
    id='portrait', 
    frames=portrait_frame,
    onPage=on_page, 
    pagesize=A4)

landscape_template = PageTemplate(
    id='landscape', 
    frames=landscape_frame, 
    onPage=on_page_landscape, 
    pagesize=landscape(A4))

doc = BaseDocTemplate(
    path,
    pageTemplates=[
    #portrait_template
    landscape_template
    ]
)

styles = getSampleStyleSheet()
custom_style = ParagraphStyle(name='CustomStyle', fontSize=8)

# NOT WOKRING
#story = [
#    Paragraph('Title 1', styles['Title']),
#    Paragraph('Title 2', styles['Title']),
#    Paragraph("<br/><br/>", styles['Normal']),
#    Paragraph('Current Total Positions', styles['Heading2']),
#    df2table2(out, custom_style, commodity_cols)
#]

# WORKING
story = [
    Paragraph('Title 1', styles['Title']),
    Paragraph('Tilte 2', styles['Title']),
    Paragraph("<br/><br/>", styles['Normal']),
    Paragraph('Current Total Positions', styles['Heading2']),
    df2table(out, custom_style)
]

doc.build(story)

Meu problema surge em algum lugar da df2table2função com a mensagem de erro completa:

unsupported operand type(s) for -=: 'float' and 'tuple'

Estou olhando para isso há horas e não consigo descobrir o que pode estar errado. Alguma ideia do que pode ser o problema?

Estou criando um relatório em PDF usando o Report Lab com base em vários dataframes do Pandas.

As tabelas exibidas no PDF precisam ter duas colunas em uma ordem específica.

aqui está um exemplo de dataframe:

df = pd.DataFrame({
        'Counterparty': ['foo', 'fizz', 'fizz', 'fizz','fizz', 'foo'],
        'Commodity': ['bar', 'bar', 'bar', 'bar','bar', 'ab cred'],
        'DealType': ['Buy', 'Buy', 'Buy', 'Buy', 'Buy', 'Buy'],
        'StartDate': ['07/01/2024', '09/01/2024', '10/01/2024', '11/01/2024', '12/01/2024', '01/01/2025'],
        'FloatPrice': [18.73, 17.12, 17.76, 18.72, 19.47, 20.26],
        'MTMValue':[10, 10, 10, 10, 10, 10]
        })

out = pd.pivot_table(df, values = 'MTMValue', index='Counterparty', columns = 'Commodity', aggfunc='sum').reset_index().rename_axis(None, axis=1).fillna(0)
out['Cumulative Exposure'] = out[out.columns[1:]].sum(axis = 1)

 Counterparty  ab cred   bar  Cumulative Exposure
0         fizz      0.0  40.0                 40.0
1          foo     10.0  10.0                 20.0

Eu preciso disto:

Counterparty      bar   ab cred  Cumulative Exposure
0         fizz     40.0  0.0                 40.0
1          foo     10.0  10.0                 20.0

onde ab credsempre estará antes cumulative exposuree depois do último commodity, já que pode haver xquantidade de commodities adicionadas aos dados ( ab credé sempre incluído como uma commodity). Mais colunas também podem ser adicionadas depois cumulative exposurea qualquer momento.

Estou processando arquivos que contêm dados em um formato inutilizável. Após processar um dos arquivos, fico com um dataframe e um valor singular.

O dataframe se parece com isto:

 df = pd.DataFrame({
        'A': ['foo', 'foo', 'foo', 'fizz', 'fizz', 'fizz', 'fizz'],
        'B': ['bar', 'bar', 'bar', 'buzz', 'buzz', 'buzz', 'baz'],
        'C': [10,10,10,10,10,10,10]
        })

 val = 20.0

O valor não deve fazer parte do meu dataframe, mas precisa ser incluído no meu cálculo TOTAL. É assim que eu o extraio do arquivo depois de lê-lo em um dataframe (ele retorna uma string, então estou convertendo para float):

if len(df.loc[df['ID'].eq("Settle"), 'C'].values) > 0:
    temp = df.loc[df['ID'].eq("Settle"), 'C']
    if temp.values[0].isnumeric():
        num = float(temp.values[0])
    else:
        num = 0.0
else:
    num = 0.0

agora preciso fazer groupby.agg()com a seguinte condição:

• Se A == 'foo'eu precisar adicionar val à soma

Este é o código básico que eu usaria para obter as somas de cada valor em A, mas não consigo descobrir como fatorar minha condição. Estou supondo que posso usar np.whereor lambdamas não tenho certeza de como usar isso com .agg()e obter minha saída.

out = df.groupby(['A'], sort=False, as_index=False).agg({"C":"sum"})

Saída esperada:

A     C
foo   50
fizz  40

Dados dois dataframes com formato idêntico:

df1

Counterparty  Product  Deal  Date          Value
foo           bar      Buy    01/01/24     10.00
foo           bar      Buy    01/01/24     10.00
foo           bar      Sell   01/01/24     10.00
foo           bar      Sell   01/01/24     10.00
fizz          bar      Buy    01/01/24     10.00
fizz          bar      Buy    01/01/24     10.00
fizz          buzz     Sell   01/01/24     10.00
fizz          buzz     Sell   01/01/24     10.00

df2

Counterparty  Product  Deal  Date          Value
foo           bar      Buy    01/01/24     11.00
foo           bar      Buy    01/01/24     09.00
foo           bar      Sell   01/01/24     09.00
foo           bar      Sell   01/01/24     10.00
fizz          bar      Buy    01/01/24     12.00
fizz          bar      Buy    01/01/24     08.00
fizz          buzz     Sell   01/01/24     09.00
fizz          buzz     Sell   01/01/24     10.00

Eu fiz isso até agora:

out = pd.pivot_table(df1, values = 'Value', index='Counterparty', columns = 'Product', aggfunc='sum').reset_index().rename_axis(None, axis=1)
out = out.fillna(0)

 Counterparty   bar  buzz
0         fizz  20.0  20.0
1          foo  40.0   0.0 

comprar Como posso girar estes para criar um visual como este:

Counterparty  Bar  Buzz  Total  col1 col2
foo           40    0      40    39    1
fizz          20    20     40    39    1

de onde col1vem df2e qual col2é a diferença entre o Totalecol1

amostra:

df1 = pd.DataFrame({
    "Counterparty": ["foo", "foo", "foo", "foo", "fizz", "fizz", "fizz", "fizz"],
    "Product": ["bar", "bar", "bar", "bar", "bar", "bar", "buzz", "buzz"],
    "Deal": ["Buy","Buy", "Sell", "Sell", "Buy", "Buy", "Sell", "Sell"],
    "Date": ["01/01/24", "01/01/24", "01/01/24", "01/01/24", "01/01/24", "01/01/24", "01/01/24", "01/01/24"],
    "Value": [10, 10, 10, 10, 10, 10, 10, 10]
    })

df2 = pd.DataFrame({
    "Counterparty": ["foo", "foo", "foo", "foo", "fizz", "fizz", "fizz", "fizz"],
    "Product": ["bar", "bar", "bar", "bar", "bar", "bar", "buzz", "buzz"],
    "Deal": ["Buy","Buy", "Sell", "Sell", "Buy", "Buy", "Sell", "Sell"],
    "Date": ["01/01/24", "01/01/24", "01/01/24", "01/01/24", "01/01/24", "01/01/24", "01/01/24", "01/01/24"],
    "Value": [11, 9, 9, 10, 12, 8, 9, 10]
    })

out = pd.pivot_table(df1, values = 'Value', index='Counterparty', columns = 'Product', aggfunc='sum').reset_index().rename_axis(None, axis=1)
out = out.fillna(0)

Quero criar uma matriz personalizada com base em várias tabelas

Dado um conjunto de dados como este:

Counterparty  Product  Deal  Date          Value
foo           bar      Buy    01/01/24     10.00
foo           bar      Buy    01/01/24     10.00
foo           bar      Sell   01/01/24     10.00
foo           bar      Sell   01/01/24     10.00
fizz          bar      Buy    01/01/24     10.00
fizz          bar      Buy    01/01/24     10.00
fizz          buzz     Sell   01/01/24     10.00
fizz          buzz     Sell   01/01/24     10.00

Eu crio uma matriz como esta:

Counterparty  Bar  Buzz  Total 
foo           40    0      40   
fizz          20    20     40
Total         60    20     80

usando Counterpartycomo linhas, Productcomo colunas e TotalValuecomo valores:

--Create Table in model

Combinations = 
CROSSJOIN(
    VALUES('table1'[Counterparty]),
    VALUES('table1'[Product])
)

--Create Measure for calculated totals

TotalValue = 
VAR CurrentCounterparty = SELECTEDVALUE(Combinations[Counterparty])
VAR CurrentProduct = SELECTEDVALUE(Combinations[Product])
VAR TotalValue = CALCULATE(
    SUM('table1'[Value]),
    'table1'[Counterparty] = IF(HASONEVALUE(Combinations[Counterparty]), CurrentCounterparty, 'table1'[Counterparty]),
    'table1'[product] = IF(HASONEVALUE(Combinations[Product]), CurrentProduct, 'table1'[Product])
)
RETURN IF(ISBLANK(TotalValue), FIXED(0, 0), TotalValue)

Também tenho uma tabela semelhante com valores diferentes que preciso usar para criar as colunas personalizadas:

Counterparty  Product  Deal  Date          Value
foo           bar      Buy    01/01/24     11.00
foo           bar      Buy    01/01/24     09.00
foo           bar      Sell   01/01/24     09.00
foo           bar      Sell   01/01/24     10.00
fizz          bar      Buy    01/01/24     12.00
fizz          bar      Buy    01/01/24     08.00
fizz          buzz     Sell   01/01/24     09.00
fizz          buzz     Sell   01/01/24     10.00

A matriz final deve ficar assim:

Counterparty  Bar  Buzz  Total  col1 col2
foo           40    0      40    39    1
fizz          20    20     40    39    1
Total         60    20     80    78    2

Acho que tenho que criar uma nova tabela a partir das duas tabelas para que tenha os valores corretos para preencher minhas colunas e então criar medidas de acordo, mas não tenho certeza de como proceder. Ou estou aberto a ouvir sugestões para uma abordagem diferente.

EDIT: Eu estava usando isso como referência, mas no exemplo eles estão criando tudo no Excel e eu não quero abordar dessa forma, pois preciso preencher dinamicamente Productsusando minhas tabelas.

Estou tentando exibir uma matriz no Power Bi, mas algumas células estão aparecendo em branco em vez de 0.

Criei uma tabela calculada e criei uma medida dentro dessa tabela para usar como Valuesparâmetro para a matriz que se parece com isto:

Value = IF(ISBLANK(SUM(Sell[Value])), 0, SUM(Sell[Value]) + 0)

OU

Value = SUM(Sell[Value]) + 0

Eu vi ambas as opções ao procurar uma maneira de atingir meu conjunto de resultados, mas não obtive a saída esperada. Existe uma maneira de atingir isso?

AMOSTRA:

mesa principal:

Counterparty  Product  Deal  Date          Value
foo           bar      Buy    01/01/24     10.00
foo           bar      Buy    01/01/24     10.00
foo           bar      Sell   01/01/24     10.00
foo           bar      Sell   01/01/24     10.00
fizz          bar      Buy    01/01/24     10.00
fizz          bar      Buy    01/01/24     10.00
fizz          buzz     Sell   01/01/24     10.00
fizz          buzz     Sell   01/01/24     10.00

Tabela calculada

Sell = FILTER('Table', 'Table'[Deal] = "Sell")

Counterparty  Product  Deal  Date          Value
foo           bar      Sell   01/01/24     10.00
foo           bar      Sell   01/01/24     10.00
fizz          buzz     Sell   01/01/24     10.00
fizz          buzz     Sell   01/01/24     10.00

Eu crio uma matriz para cada tabela usando Contraparte como linhas, Produto como colunas e crio as medidas acima para o parâmetro de valor que crio em cada tabela.

SAÍDA para tabela de vendas:

Counterparty   BAR      BUZZ
foo           20.00   (blank)
fizz         (blank)   20.00

SAÍDA ESPERADA para a tabela de vendas:

Counterparty   BAR      BUZZ
foo           20.00      0
fizz            0     20.00

Dado este tipo de estrutura de tabela:

Counterparty  Product  Deal  Date          Value
foo           bar      Buy    01/01/24     10.00
foo           bar      Buy    01/01/24     10.00
foo           bar      Sell   01/01/24     10.00
foo           bar      Sell   01/01/24     10.00
fizz          buzz     Buy    01/01/24     10.00
fizz          buzz     Buy    01/01/24     10.00
fizz          buzz     Sell   01/01/24     10.00
fizz          buzz     Sell   01/01/24     10.00

Preciso criar mais duas tabelas parecidas com esta:

Counterparty  Product  Deal  Date          Value
foo           bar      Buy    01/01/24     10.00
foo           bar      Buy    01/01/24     10.00
fizz          buzz     Buy    01/01/24     10.00
fizz          buzz     Buy    01/01/24     10.00

E

Counterparty  Product  Deal  Date          Value
foo           bar      Sell   01/01/24     10.00
foo           bar      Sell   01/01/24     10.00
fizz          buzz     Sell   01/01/24     10.00
fizz          buzz     Sell   01/01/24     10.00

Sou novo no Power Bi, mas no editor de consultas, como posso criar mais duas tabelas com base em alguma condição como a mostrada acima? Também preciso preservar a tabela principal. Algo assim é possível no editor de consultas?

Editar: Posso executar um script Python usando pandas assim:

import pandas as pd

df = pd.DataFrame(dataset)
df = df[df['DealType'].eq('Buy/Sell')]

Mas eu quero saber o equivalente DAX para isso

Tenho duas tabelas que contêm o mesmo tipo de dados, uma com dados do dia atual e outra com dados do dia anterior:

Atual:

CREATE TABLE Current (
    Col1 VARCHAR(50),
    Col2 VARCHAR(10), 
    Col3 VARCHAR(2), 
    Col4 DATE,       
    Col5 INT,         
    Col6 NUMERIC(5,2)
);

INSERT INTO Current (Col1, Col2, Col3, Col4, Col5, Col6)
VALUES 
('ItemA', CASE WHEN LEFT('Ho', 1) = UPPER(LEFT('Ho', 1)) THEN 'Sell' ELSE 'Buy' END, 'Ho', '2025-07-01', 12345, 10.50),
('ItemA', CASE WHEN LEFT('oH', 1) = UPPER(LEFT('oH', 1)) THEN 'Sell' ELSE 'Buy' END, 'oH', '2025-08-01', 23456, 20.75),
('ItemB', CASE WHEN LEFT('Br', 1) = UPPER(LEFT('Br', 1)) THEN 'Sell' ELSE 'Buy' END, 'Br', '2025-07-01', 34567, 30.80),
('ItemC', CASE WHEN LEFT('rB', 1) = UPPER(LEFT('rB', 1)) THEN 'Sell' ELSE 'Buy' END, 'rB', '2025-09-01', 45678, 40.25),
('ItemC', CASE WHEN LEFT('Ho', 1) = UPPER(LEFT('Ho', 1)) THEN 'Sell' ELSE 'Buy' END, 'Ho', '2025-08-01', 56789, 50.60),
('ItemD', CASE WHEN LEFT('Br', 1) = UPPER(LEFT('Br', 1)) THEN 'Sell' ELSE 'Buy' END, 'Br', '2025-09-01', 67890, 60.10),
('ItemE', CASE WHEN LEFT('rB', 1) = UPPER(LEFT('rB', 1)) THEN 'Sell' ELSE 'Buy' END, 'rB', '2025-07-01', 78901, 70.95),
('ItemE', CASE WHEN LEFT('Ho', 1) = UPPER(LEFT('Ho', 1)) THEN 'Sell' ELSE 'Buy' END, 'Ho', '2025-08-01', 89012, 15.35);

Anterior:

CREATE TABLE Previous (
    Col1 VARCHAR(50),
    Col2 VARCHAR(10), 
    Col3 VARCHAR(2), 
    Col4 DATE,       
    Col5 INT,         
    Col6 NUMERIC(5,2)
);

INSERT INTO Previous (Col1, Col2, Col3, Col4, Col5, Col6)
VALUES 
('ItemA', CASE WHEN LEFT('Ho', 1) = UPPER(LEFT('Ho', 1)) THEN 'Sell' ELSE 'Buy' END, 'Ho', '2025-07-01', 12350, 10.55),
('ItemA', CASE WHEN LEFT('oH', 1) = UPPER(LEFT('oH', 1)) THEN 'Sell' ELSE 'Buy' END, 'oH', '2025-08-01', 23461, 20.80),
('ItemB', CASE WHEN LEFT('Br', 1) = UPPER(LEFT('Br', 1)) THEN 'Sell' ELSE 'Buy' END, 'Br', '2025-07-01', 34572, 30.85),
('ItemC', CASE WHEN LEFT('rB', 1) = UPPER(LEFT('rB', 1)) THEN 'Sell' ELSE 'Buy' END, 'rB', '2025-09-01', 45683, 40.30),
('ItemC', CASE WHEN LEFT('Ho', 1) = UPPER(LEFT('Ho', 1)) THEN 'Sell' ELSE 'Buy' END, 'Ho', '2025-08-01', 56794, 50.65),
('ItemD', CASE WHEN LEFT('Br', 1) = UPPER(LEFT('Br', 1)) THEN 'Sell' ELSE 'Buy' END, 'Br', '2025-09-01', 67905, 60.15),
('ItemE', CASE WHEN LEFT('rB', 1) = UPPER(LEFT('rB', 1)) THEN 'Sell' ELSE 'Buy' END, 'rB', '2025-07-01', 78916, 70.90),
('ItemE', CASE WHEN LEFT('Ho', 1) = UPPER(LEFT('Ho', 1)) THEN 'Sell' ELSE 'Buy' END, 'Ho', '2025-08-01', 89027, 15.40);

Eu executo esta consulta com as 2 tabelas:

SELECT Col1, SUM(Col5) AS 'sum', 'C' AS 'Flag'
FROM Current
GROUP BY Col1
UNION
SELECT Col1, SUM(Col5) AS 'sum', 'P' AS 'Flag'
FROM Previous
GROUP BY Col1
ORDER BY Col1;

que retorna:

Col1    Sum    Flag
ItemA   35801   C
ItemA   35811   P
ItemB   34567   C
ItemB   34572   P
ItemC   102477  P
ItemC   102467  C
ItemD   67905   P
ItemD   67890   C
ItemE   167913  C
ItemE   167943  P

Adicionei a coluna flag para maior clareza, para que você possa saber de onde os valores estão vindo. Preciso editar esta consulta para retornar uma tabela como esta:

Col1    Current Sum Previous Sum    Difference
ItemA   35811.          35801           10
ItemB   34572           34567            5
ItemC   102477          102467          10
ItemD   67905           67890           15
ItemE   167943          167913          30

mas não consigo descobrir como selecionar os valores corretos a serem agregados, pois as tabelas são idênticas.

Editar: Devo observar que as tabelas exibem dados do dia atual e dados do dia anterior, então é possível que qualquer uma das tabelas contenha valores sem correspondência. Por exemplo, uma linha de dados pode "expirar" e ser incluída apenas na tabela anterior e não na atual. Uma linha também pode ser "adicionada" e ser incluída apenas na atual e não na anterior. Nesses casos, um valor precisaria ser preenchido como 0

Estou mesclando um dataframe com um dataframe estático (uma tabela em uma planilha) que resulta em um dataframe parecido com este:

Counterparty    DealType       Commodity   Product     
        Aron      Buy           AAA         NaN  
        Aron      Buy           AAA         NaN  
        Aron      Buy           AAA         NaN  
        Aron      Buy           BBB         prod1  
        Aron      Buy           BBB         prod1  
        Aron      Buy           BBB         prod1  
        Aron      Buy          CCC          NaN  
        Aron      Buy          CCC          NaN  
        Aron      Buy          CCC          NaN 

Se o dataframe não tiver valores NaN na coluna Produto, a mesclagem foi bem-sucedida e meu programa poderá continuar.

No entanto, se existirem valores NaN na coluna do produto, preciso atualizar minha planilha com os valores ausentes.

este é o código que tenho que retorna verdadeiro se houver algum valor NaN:

if (df['Product'].isnull().any()):
    print('missing values found')
    # get list of missing values
    sys.exit(0)

mas quero retornar uma lista dos valores ausentes, como['AAA', 'CCC']

Eu tenho um dataframe parecido com este:

Put/Call StrikePrice fixedprice floatprice fixedspread floatspread
Put          10           0         20           0           0
Put          10           0         20           0           0
nan           0           0          0           13          15
nan           0           0          0           14          16

Se a coluna de venda/compra tiver o valor 'Put', preciso pegar o valor da coluna de preço de exercício e colocá-lo na coluna de spread fixo, e preciso pegar o valor da coluna de preço flutuante e colocá-lo na coluna de preço flutuante coluna espalhada. Assim que os valores estiverem nos lugares corretos, posso me livrar da coluna Put/Call, coluna de preço de exercício, coluna de preço flutuante e coluna de preço fixo. 

a saída deve ser semelhante a esta:

  fixedspread floatspread
       10          20
       10          20
       13          15
       14          16

Tenho vários dataframes que usam as mesmas funções para retirar todos os valores. No entanto, alguns dos valores são tuplas e ocorre um erro sempre que encontro a remoção de uma tupla.

Minha função fica assim:

for col in df.columns:
        if df[col].dtype == 'object':   
            df[col] = df[col].apply(lambda x: str(x).strip())

Tenho outra função para um dataframe específico que sempre terá tuplas:

for col in df.columns:
        if df[col].dtype == 'object':   
            df[col] = df[col].apply(lambda x: str(x).strip())

    df['Commodity'] = [(x.strip() for x in ls) for ls in df['Commodity'].values]
    df['Commodity'] = df['Commodity'].apply(sorted)

A segunda função sempre gerará um erro quando chegar à coluna Commodity porque não manipulará as tuplas. Como posso lidar com esse caso específico na primeira função?

Estou mesclando dois dataframes. O primeiro dataframe se parece com isto:

A       B        C           D
party1  asset1   product1    Buy
party1  asset1   product2    Sell
party2  asset2   product1    Buy
party2  asset2   product2    Sell

O segundo dataframe se parece com isto:

A       B        D
party1  asset1   Buy
party1  asset1   Sell
party2  asset2   Buy
party2  asset2   Sell

Eu mesclo os dataframes assim:

df2 = df.merge(df1, on=['A', 'B', 'D'])

que retorna:

A       B        D      C
party1  asset1   Buy    product1
party1  asset1   Sell   product2
party2  asset2   Buy    product1
party2  asset2   Sell   product2

Preciso substituir os valores da coluna 'B' pelos valores da coluna 'C', mantendo o mesmo nome 'B'.

A       B          D      
party1  product1   Buy    
party1  product2   Sell   
party2  product1   Buy    
party2  product2   Sell   

Qualquer sugestão sobre como conseguir isso ajudaria.

Eu tenho um dataframe parecido com este:

ID  TradeDate    party    Deal   Asset  Start       Expire      Fixed   Quantity  MTM      Float
1   04/11/2024   party1   Sell   HO     01/01/2024  02/01/2024  10.00   1000     2500.00   10.00
1   04/11/2024   party1   Sell   HO     01/01/2024  02/01/2024  10.00   1000     2500.00   10.00
1   04/11/2024   party1   Sell   HO     01/01/2024  02/01/2024  10.00   1000     2500.00   10.00
1   04/11/2024   party1   Buy    HO     01/01/2024  02/01/2024  10.00   1000     2500.00   10.00
1   04/11/2024   party1   Buy    HO     01/01/2024  02/01/2024  10.00   1000     2500.00   10.00
1   04/11/2024   party1   Sell   WTI    01/01/2024  02/01/2024  10.00   1000     2500.00   10.00
1   04/11/2024   party1   Sell   WTI    01/01/2024  02/01/2024  10.00   1000     2500.00   10.00
1   04/11/2024   party1   Buy    WTI    01/01/2024  02/01/2024  10.00   1000     2500.00   10.00

Agrupo os dados por Start, Asset e Deal e realizo cálculos para transformar o dataframe nisso:

groups = df.groupby(['Start', 'Asset', 'Deal'])

ID  TradeDate    party    Deal   Asset  Start       Expire      Fixed   Quantity  MTM      Float
1   04/11/2024   party1   Sell   HO     01/01/2024  02/01/2024  10.00   1000     2500.00   10.00
1   04/11/2024   party1   Sell   HO     01/01/2024  02/01/2024  10.00   1000     2500.00   10.00
1   04/11/2024   party1   Sell   HO     01/01/2024  02/01/2024  10.00   1000     2500.00   10.00
total                                                                   3000     7500.00   

ID  TradeDate    party    Deal   Asset  Start       Expire      Fixed   Quantity  MTM      Float
1   04/11/2024   party1   Buy    HO     01/01/2024  02/01/2024  10.00   1000     2500.00   10.00
1   04/11/2024   party1   Buy    HO     01/01/2024  02/01/2024  10.00   1000     2500.00   10.00
total                                                                   3000     5000.00   

ID  TradeDate    party    Deal   Asset  Start       Expire      Fixed   Quantity  MTM      Float
1   04/11/2024   party1   Sell   WTI    01/01/2024  02/01/2024  10.00   1000     2500.00   10.00
1   04/11/2024   party1   Sell   WTI    01/01/2024  02/01/2024  10.00   1000     2500.00   10.00
total                                                                   3000     5000.00   

ID  TradeDate    party    Deal   Asset  Start       Expire      Fixed   Quantity  MTM      Float
1   04/11/2024   party1   Buy    WTI    01/01/2024  02/01/2024  10.00   1000     2500.00   10.00
total                                                                   1000     2500.00   

Meu objetivo é transformar esses grupos em outro momento para que eu possa gerar apenas os dados necessários. A saída esperada para esta etapa deve ser semelhante a esta:

party   Deal  Asset Start        MTM       Float
party1  Sell  HO    01/01/2024   7500.00   10.00 
party1  Buy   HO    01/01/2024   5000.00   10.00
party1  Sell  WTI   01/01/2024   5000.00   10.00
party1  Buy   WTi   01/01/2024   2500.00   10.00                                                         

Preciso realizar algum tipo de outro agrupamento? ou existe outra função que poderia conseguir isso? Qualquer sugestão ajudaria.

Nota: na segunda etapa, esses são dataframes individuais que vêm de uma lista. Você pode precisar de uma etapa intermediária para concatena-los e chegar ao resultado final.

Eu tenho um dataframe:

ID   Deal  Party  Commodity       startdate  enddate  price    quantity  mtmvalue
---- ----- -----  ---------       ---------  -------  ------   --------  ---------
J1   Sell   J   (stock1, stock2)   01Jan23   01Feb23   10.00      10      100.00
J4   Buy    J   (stock1, stock2)   01Jan23   01Feb23   5.00       5       25.00
J2   Sell   J   (stock1, stock2)   01Jan23   01Feb23   10.00      10      100.00
J3   Buy    J   (stock1, stock2)   01Jan23   01Feb23   5.00       10      50.00

Preciso agrupar os dados por negócio, mercadoria e data de início para que meu dataframe fique assim:

ID   Deal  Party  Commodity       startdate  enddate  price    quantity  mtmvalue
---- ----- -----  ---------       ---------  -------  ------   --------  ---------
J1   Sell   J   (stock1, stock2)   01Jan23   01Feb23   10.00      10      100.00
J2   Sell   J   (stock1, stock2)   01Jan23   01Feb23   10.00      10      100.00
J3   Buy    J   (stock1, stock2)   01Jan23   01Feb23   5.00       10      50.00
J4   Buy    J   (stock1, stock2)   01Jan23   01Feb23   5.00       5       25.00

Estou fazendo isso que criará dois grupos, mas quero isso em um dataframe:

df.groupby(['Deal', 'Commodity', StartDate'])

Como eu manteria os agrupamentos no dataframe original?

Já postei essa pergunta antes, mas ela continua sendo fechada devido a perguntas semelhantes, mas essas soluções não me ajudaram aqui.

Tenho um dataframe que precisa ser agrupado por 3 colunas diferentes. A partir dos agrupamentos resultantes, preciso realizar cálculos e depois aplicar o resultado a cada linha em uma nova coluna.

Meus dados ficam assim:

ID   Deal  Party  Commodity       startdate  enddate  fixedpricestrike  quantity  mtmvalue
---- ----- -----  ---------       ---------  -------  ----------------  --------  ---------
J1   Sell   J   (stock1, stock2)   01Jan23   01Feb23        10.00          10      100.00
J2   Sell   J   (stock1, stock2)   01Jan23   01Feb23        10.00          10      100.00
J3   Buy    J   (stock1, stock2)   01Jan23   01Feb23        5.00           10      50.00
J4   Buy    J   (stock1, stock2)   01Jan23   01Feb23        5.00           5       25.00

Meu objetivo é agrupar os dados por [Deal, commodity, startdate] para que os dados resultantes fiquem assim:

ID   Deal  Party  Commodity       startdate  enddate  fixedpricestrike  quantity  mtmvalue
---- ----- -----  ---------       ---------  -------  ----------------  --------  ---------
J1   Sell   J   (stock1, stock2)   01Jan23   01Feb23        10.00          10      100.00
J2   Sell   J   (stock1, stock2)   01Jan23   01Feb23        10.00          10      100.00

ID   Deal  Party  Commodity       startdate  enddate  fixedpricestrike  quantity  mtmvalue
---- ----- -----  ---------       ---------  -------  ----------------  --------  ---------
J3   Buy    J   (stock1, stock2)   01Jan23   01Feb23        5.00           10      50.00
J4   Buy    J   (stock1, stock2)   01Jan23   01Feb23        5.00           5       25.00

A partir disso, preciso usar uma fórmula para calcular um 'fprice' e adicioná-lo a cada linha assim:

ID   Deal  Party  Commodity       startdate  enddate  fixedpricestrike  quantity  mtmvalue fprice
---- ----- -----  ---------       ---------  -------  ----------------  --------  --------- -----
J1   Sell   J   (stock1, stock2)   01Jan23   01Feb23        10.00          10      100.00    0
J2   Sell   J   (stock1, stock2)   01Jan23   01Feb23        10.00          10      100.00    0

ID   Deal  Party  Commodity       startdate  enddate  fixedpricestrike  quantity  mtmvalue fprice
---- ----- -----  ---------       ---------  -------  ----------------  --------  --------- -----
J3   Buy    J   (stock1, stock2)   01Jan23   01Feb23        5.00           10      50.00     1.25
J4   Buy    J   (stock1, stock2)   01Jan23   01Feb23        5.00           10      25.00     1.25

Meu problema está na próxima etapa, quando tento adicionar o fprice de volta ao dataframe original, tenho esta linha de código:

df['fprice'] = df.groupby(['StartDate', 'Commodity', 'Deal']).apply(lambda group: -(group['MTMValue'].sum() - (group['FixedPriceStrike'] * group['Quantity']).sum()) / group['Quantity'].sum()).reset_index(drop=True)

que retorna este dataframe:

ID   Deal  Party  Commodity       startdate  enddate  fixedpricestrike  quantity  mtmvalue fprice
---- ----- -----  ---------       ---------  -------  ----------------  --------  --------- -----
J1   Sell   J   (stock1, stock2)   01Jan23   01Feb23        10.00          10      100.00    0
J2   Sell   J   (stock1, stock2)   01Jan23   01Feb23        10.00          10      100.00    1.25
J3   Buy    J   (stock1, stock2)   01Jan23   01Feb23        5.00           10      50.00     
J4   Buy    J   (stock1, stock2)   01Jan23   01Feb23        5.00           10      25.00     

quando o resultado deve ser parecido

ID   Deal  Party  Commodity       startdate  enddate  fixedpricestrike  quantity  mtmvalue fprice
---- ----- -----  ---------       ---------  -------  ----------------  --------  --------- -----
J1   Sell   J   (stock1, stock2)   01Jan23   01Feb23        10.00          10      100.00    0
J2   Sell   J   (stock1, stock2)   01Jan23   01Feb23        10.00          10      100.00    0
J3   Buy    J   (stock1, stock2)   01Jan23   01Feb23        5.00           10      50.00     1.25
J4   Buy    J   (stock1, stock2)   01Jan23   01Feb23        5.00           10      25.00     1.25

Também sou relativamente novo no uso de pandas e não tenho certeza de por que meu resultado está saindo dessa maneira. Qualquer sugestão ajudaria