's questions

IMAGEM DA PLANILHA DO GOOGLE

Quais seriam as fórmulas de matriz em A1, B1, C1 e D1 (separadamente) para fornecer as colunas de saída desejadas, conforme mostrado.

Link da Planilha Google

OBSERVAÇÃO: A diferença entre "Cabeçalhos Principais" (PARENTES, AMIGOS, AMIGOS DE NEGÓCIOS) e "nomes" é que os "Cabeçalhos Principais" têm 1 letra de espaço no início e no fim.

As colunas A, B e C são todas iguais, a única diferença é que para os "Títulos Principais" a coluna A fornece alfabetos, a coluna B fornece números e a coluna C fornece algarismos romanos.

CONDIÇÃO PARA NUMERAÇÃO SERIAL:
(1) A numeração serial é feita completamente com base nas colunas: NOMES E PAX.
(2) Se PAX for 0, a saída estará em branco.

PARA as colunas A, B, C:
Quando PAX estiver em branco:
-> se for um "Título principal", a saída será um alfabeto OU
-> se for um "nome", a saída estará em branco.

PARA a coluna D:
Quando PAX estiver em branco:
-> se for um "Título principal", a saída estará em branco OU
-> se for um "nome", a saída será uma numeração serial até o próximo "Título principal", depois reiniciará de 1 até o próximo "Título principal" e assim por diante.

EDIT:
As colunas NAMES e PAX são entradas, o restante é a saída necessária.

Dados:

Tenho uma estrutura complexa de dicionário aninhado e preciso remover elementos com base nos valores de um dicionário aninhado. Meu dicionário se parece com isto:

my_dict = {
    'item1': {'name': 'Apple', 'price': 1.0, 'category': {'id': 1, 'name': 'Fruit'}},
    'item2': {'name': 'Banana', 'price': 0.5, 'category': {'id': 1, 'name': 'Fruit'}},
    'item3': {'name': 'Carrot', 'price': 0.75, 'category': {'id': 2, 'name': 'Vegetable'}},
    'item4': {'name': 'Broccoli', 'price': 1.5, 'category': {'id': 2, 'name': 'Vegetable'}}
}

Quero filtrar este dicionário para incluir apenas itens pertencentes à categoria "Fruta". Tentei o seguinte código:

new_dict = {}
for key, value in my_dict.items():
    if value['category']['name'] == 'Fruit':
        new_dict[key] = value
print(new_dict)

Isso funciona, mas estou me perguntando se há uma maneira mais concisa ou Pythonica de fazer isso, talvez usando compreensão de dicionário ou uma função de filtragem como filter().

Dado

class Foo {
  x = 1;
  y = 2;
}
class Bar extends Foo {
  override x = 11;
  z = 3;
}

É possível derivar Foodado Barautomaticamente? Como Superclass<Bar> === Foo?

Estou criando uma aplicação na qual escrevi uma função para poder pegar imagens da web com extensões específicas mas tem um erro aqui que não sei como resolver Me ajudem

erro de texto

/C:/Users/sina%20saffar/AppData/Local/Pub/Cache/hosted/pub.dev/flutter_dropzone_web-3.0.13/lib/flutter_dropzone_plugin.dart:64:25: Error: The return type of the method 'FlutterDropzonePlugin.pickFiles' is 'Future<List<dynamic>>', which does not match the return type, 'Future<List<DropzoneFileInterface>>', of the overridden method, 'FlutterDropzonePlatform.pickFiles'.
 - 'Future' is from 'dart:async'.
 - 'List' is from 'dart:core'.
 - 'DropzoneFileInterface' is from 'package:flutter_dropzone_platform_interface/dropzone_file_interface.dart' ('/C:/Users/sina%20saffar/AppData/Local/Pub/Cache/hosted/pub.dev/flutter_dropzone_platform_interface-2.2.0/lib/dropzone_file_interface.dart').
Change to a subtype of 'Future<List<DropzoneFileInterface>>'.
  Future<List<dynamic>> pickFiles(bool multiple,
                        ^
/C:/Users/sina%20saffar/AppData/Local/Pub/Cache/hosted/pub.dev/flutter_dropzone_platform_interface-2.2.0/lib/flutter_dropzone_platform_interface.dart:97:39: Context: This is the overridden method ('pickFiles').
  Future<List<DropzoneFileInterface>> pickFiles(bool multiple,

selecione a função de imagem local:

 Future<void> selectLocalImages() async {
    final files = await dropzoneViewController.pickFiles(
      multiple: true,
      mime: ['image/jpeg', 'image/png'],
    );

    if (files.isNotEmpty) {
      for (var file in files) {
        if (file is html.File) {
          final bytes = await dropzoneViewController.getFileData(file);
          final image = ImageModel(
            url: '',
            file: file,
            folder: '',
            filename: file.name,
            localImageToDisplay: Uint8List.fromList(bytes),
          );
          selectedImagesToUpload.add(image);
        }
      }
    }
  }

Estou encontrando um erro ao tentar obter o token usando o Firebase Messaging no meu aplicativo Flutter iOS. A mensagem de erro é a seguinte:

FLTFirebaseMessaging: An error occurred while calling method Messaging#getToken, errorOrNil => {    NSLocalizedFailureReason = "Invalid fetch response, expected 'token' or 'Error' key";}

[ERROR:flutter/runtime/dart_vm_initializer.cc(41)] Unhandled Exception: [firebase_messaging/unknown] An unknown error has occurred.
#0      StandardMethodCodec.decodeEnvelope (package:flutter/src/services/message_codecs.dart:651:7)
#1      MethodChannel._invokeMethod (package:flutter/src/services/platform_channel.dart:334:18)
<asynchronous suspension>
#2      MethodChannel.invokeMapMethod (package:flutter/src/services/platform_channel.dart:534:43)
<asynchronous suspension>
#3      MethodChannelFirebaseMessaging.getToken (package:firebase_messaging_platform_interface/src/method_channel/method_channel_messaging.dart:248:11)
<asynchronous suspension>
#4      FCMToken.getFcm (package:instahire/firebase/fcm_token.dart:5:21)
<asynchronous suspension>
#5      SplashController.getToken (package:instahire/controllers/splash_controller.dart:42:23)
<asynchronous suspension>

Até ontem estava funcionando bem, de repente ocorreu esse erro. Como resolver isso?

Estou configurando o Stripe para pagamentos no meu projeto e estou tendo alguns problemas para gerenciar clientes.

O que estou tentando fazer é criar um novo cliente e armazenar o ID do cliente do Stripe no meu banco de dados quando o usuário cria uma sessão de checkout. O problema é que, depois que o usuário conclui o pagamento, outro cliente está sendo criado.

@app.post('/create-checkout-session')
async def create_checkout_session(request: Request):
  

    data = await request.json()

    price_id = data['price_id']
    user_id = data['user_id']
    base_url = data['base_url']
    stripe_customer_id = data.get('stripe_customer_id')

    try:
        if stripe_customer_id is not None:
            stripe_customer = stripe.Customer.retrieve(stripe_customer_id)

            if stripe_customer:
                print('stripe_customer', stripe_customer)
                return  
        else:
            print('request', request)
            stripe_customer = stripe.Customer.create(metadata={"user_id": user_id})
            customer_id = stripe_customer.id
            await update_user_with_stripe_customer_id(user_id, customer_id)  
        
        checkout_session = stripe.checkout.Session.create(
            customer=stripe_customer_id,
            line_items=[
                {
                    'price': price_id,
                    'quantity': 1,
                },
            ],
            mode='subscription',
            success_url=base_url + '/payment-success',
            cancel_url=base_url + '?canceled=true',
            client_reference_id=user_id,
        )
        
        logger.info(f"Checkout session created successfully: {checkout_session.id}")
        return JSONResponse(content={"url": checkout_session.url}, status_code=200)
    except stripe.error.StripeError as e:
        logger.error(f"Stripe error: {str(e)}")
        raise HTTPException(status_code=400, detail=str(e))
    except Exception as e:
        logger.error(f"Error creating checkout session: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))

async def update_user_with_stripe_customer_id(user_id: str, stripe_customer_id: str):
    db = firestore.client()
    user_ref = db.collection('customers').where(filter=FieldFilter("user_id", "==", user_id))
    user_docs = user_ref.get()

    if user_docs:
        user_doc = user_docs[0]
        user_doc.reference.update({
            'stripe_customer_id': stripe_customer_id
        })
        print(f"Updated user {user_id} with Stripe customer ID {stripe_customer_id}")
    else:
        logger.error(f"User {user_id} not found in database")
        raise HTTPException(status_code=404, detail="User not found") 

Após a conclusão de uma sessão de checkout e o pagamento bem-sucedido, quero atualizar meu banco de dados para dar ao usuário os créditos alocados. No entanto, estou recebendo um erro 404 usuário não encontrado.

@app.post('/webhook')
async def webhook_received(request: Request):
    print("Webhook received!")
    payload = await request.body()
    sig_header = request.headers.get('stripe-signature')
    logger.info(f"Stripe signature: {sig_header}")

    try:
        event = stripe.Webhook.construct_event(
            payload, sig_header, STRIPE_WEBHOOK_SECRET
        )
        print(f"Event constructed: {event['type']}")
    except ValueError as e:
        logger.info(f"Invalid payload: {str(e)}")
        raise HTTPException(status_code=400, detail='Invalid payload')
    except stripe.error.SignatureVerificationError as e:
        logger.info(f"Invalid signature: {str(e)}")
        raise HTTPException(status_code=400, detail='Invalid signature')

    if event['type'] == 'checkout.session.completed':
        logger.info("Checkout session completed event received")
        return
        session = event['data']['object']
        try:
            result = await handle_checkout_session_completed(session)
            return JSONResponse(content={"status": "success", "result": result}, status_code=200)
        except Exception as e:
            logger.error(f"Error handling checkout session: {str(e)}")
            return JSONResponse(content={"status": "error", "message": str(e)}, status_code=500)
    elif event['type'] =='invoice.paid':
        logger.info("Invoice paid event received")
        session = event['data']['object']
        try:
            result = await handle_invoice_paid(session)
            return JSONResponse(content={"status": "success", "result": result}, status_code=200)
        except Exception as e:
            logger.error(f"Error handling invoice paid: {str(e)}")
            return JSONResponse(content={"status": "error", "message": str(e)}, status_code=500)
    else:
        logger.info(f"Unhandled event type: {event['type']}")

async def handle_invoice_paid(session):
    print('session', session)
    credits = session.get('lines').data[0].plan.metadata.credits
    tier = session.get('lines').data[0].plan.metadata.tier
    stripe_customer_id = session.get('customer')
    print('credits', credits, tier, stripe_customer_id)

    if credits:
        db = firestore.client()
        user_ref = db.collection('customers').where(filter=FieldFilter("stripe_customer_id", "==", stripe_customer_id))
        user_docs = user_ref.get()

        if user_docs:
            user_doc = user_docs[0]
            user_doc.reference.update({
                'credits': credits,
                'current_subscription_tier': tier,
                'stripe_customer_id': stripe_customer_id
            })
            updated_user_doc = user_doc.reference.get()
            updated_user_data = updated_user_doc.to_dict()
            return JSONResponse(content={"updated_user": updated_user_data}, status_code=200)
        else:
            print(f"User document not found for user_id: {stripe_customer_id}")
            raise HTTPException(status_code=404, detail="User not found")
    else:
        print(f"credits: {credits} not found")  

Eu tentei diferentes implementações para criar o cliente. No final, preciso atualizar meu banco de dados com o id do cliente, mas meu problema é que, como vários usuários estão sendo criados, há vários ids de clientes.

Como é possível que a mesma consulta funcione na instância MySQL do Windows, mas não funcione na instância MySQL do Ubuntu?

As versões de instância são bem próximas:

• Janelas: 8.0.16
• Ubuntu: 8.0.39-0ubuntu0.24.04.2

Windows: @@sql_mode: TABELAS_DE_TRANS_TRIBUIÇÃO_TRIBUÍDAS, SEM_SUBSTITUIÇÃO_DO_ENGINE

Ubuntu: @@sql_mode: SOMENTE_GRUPO_COMPLETO_POR, TABELAS_DE_TRANSFERÊNCIA_ESTRITAS, SEM_DATA_ZERO, SEM_DATA_ZERO, ERRO_PARA_DIVISÃO_POR_ZERO, SEM_SUBSTITUIÇÃO_DO_MECANISMO

O erro no Ubuntu:

ERRO 3065 (HY000): A expressão nº 1 da cláusula ORDER BY não está na lista SELECT, faz referência à coluna 'p.priority' que não está na lista SELECT; isso é incompatível com DISTINCT

A pergunta:

SELECT DISTINCT 
    `id`, `date_created`, `date_last_update`, `text_id_map`, `address_search_aid`, `lat`, `lng`, 
    `street_line1`, `street_line2`, `zip`, `company_status`, `compassion_level`, `emails`, 
    `phones`, `social_media`, `urls`, `description`, `importance`, `name`, `object_status`, 
    `search_aid`, `short_name`, `created_by_id`, `last_update_by_id`, `alternate_country_id`,
    `city_id`, `parent_id`, `city_region_id`, `autocomplete`, `sitemap_xml`
FROM (
    
    SELECT p.*, 0 AS `priority`, CASE WHEN `parent_id` IS NULL THEN 1 ELSE 0 END AS `is_parent`
    FROM `provider` p 
    CROSS JOIN JSON_TABLE( JSON_KEYS(`name`), '$[*]' COLUMNS (locale VARCHAR(10) PATH '$') ) AS l 
    CROSS JOIN JSON_TABLE( JSON_EXTRACT(`name`, CONCAT('$.', l.locale)), '$' COLUMNS (`jsonval` VARCHAR(2048) PATH '$') ) AS j
    WHERE
        INSTR( CONCAT(' ', REPLACE(j.jsonval, '-', ' '), ' '), CONCAT(' ', 'web', ' ') ) > 0
        AND
        INSTR( CONCAT(' ', REPLACE(j.jsonval, '-', ' '), ' '), CONCAT(' ', 'kon', ' ') ) > 0 
    
    UNION
    
    SELECT *, 
        CASE 
            WHEN 
                INSTR( CONCAT(' ', `autocomplete`, ' '), CONCAT(' ', 'web', ' ') ) > 0 
                AND 
                INSTR( CONCAT(' ', `autocomplete`, ' '), CONCAT(' ', 'kon', ' ') ) > 0 
            THEN 1 
            WHEN INSTR( `autocomplete`, 'web' ) > 0 AND INSTR( `autocomplete`, 'kon' ) > 0 THEN 2 
            ELSE 3 
        END `priority`, 
        CASE 
            WHEN parent_id IS NULL THEN 1 
            ELSE 0 
        END AS `is_parent`
    FROM `provider`
    
) p
WHERE `priority` < 3
ORDER BY `priority`, `is_parent` DESC
LIMIT 10;

A tabela é criada desta forma:

CREATE TABLE `provider` (
  `id` int NOT NULL,
  `date_created` varchar(80) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `date_last_update` varchar(80) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `text_id_map` text COLLATE utf8mb4_unicode_ci,
  `address_search_aid` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `lat` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `lng` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `street_line1` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `street_line2` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `zip` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `company_status` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `compassion_level` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `emails` varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `phones` varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `social_media` text COLLATE utf8mb4_unicode_ci,
  `urls` varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `description` text COLLATE utf8mb4_unicode_ci,
  `importance` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `name` text COLLATE utf8mb4_unicode_ci,
  `object_status` varchar(16) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `search_aid` text COLLATE utf8mb4_unicode_ci,
  `short_name` text COLLATE utf8mb4_unicode_ci,
  `created_by_id` int DEFAULT NULL,
  `last_update_by_id` int DEFAULT NULL,
  `alternate_country_id` int DEFAULT NULL,
  `city_id` int DEFAULT NULL,
  `parent_id` int DEFAULT NULL,
  `city_region_id` int DEFAULT NULL,
  `autocomplete` text COLLATE utf8mb4_unicode_ci,
  `sitemap_xml` text CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci,
  PRIMARY KEY (`id`),
  KEY `FKotfd80u3xayhxxjrvtpclqwe6` (`created_by_id`),
  KEY `FK7gqnbcylk4ghwciki0779g32u` (`last_update_by_id`),
  KEY `FKk6jlj4kwu3hi5kl4a4qqso7j3` (`alternate_country_id`),
  KEY `FKrlh8uhcluf8si4vfbgdw3w6p1` (`city_id`),
  KEY `FK6psluxn6a0b64bcxggfuum2l0` (`parent_id`),
  KEY `FKegsn16mm766i6j5du01dlvn6` (`city_region_id`),
  CONSTRAINT `FK6psluxn6a0b64bcxggfuum2l0` FOREIGN KEY (`parent_id`) REFERENCES `provider` (`id`),
  CONSTRAINT `FK7gqnbcylk4ghwciki0779g32u` FOREIGN KEY (`last_update_by_id`) REFERENCES `veg_user` (`id`),
  CONSTRAINT `FKegsn16mm766i6j5du01dlvn6` FOREIGN KEY (`city_region_id`) REFERENCES `city_region` (`id`),
  CONSTRAINT `FKk6jlj4kwu3hi5kl4a4qqso7j3` FOREIGN KEY (`alternate_country_id`) REFERENCES `country` (`id`),
  CONSTRAINT `FKotfd80u3xayhxxjrvtpclqwe6` FOREIGN KEY (`created_by_id`) REFERENCES `veg_user` (`id`),
  CONSTRAINT `FKrlh8uhcluf8si4vfbgdw3w6p1` FOREIGN KEY (`city_id`) REFERENCES `city` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci

Captura de tela de Heidi no Windows; consulta copiada desta pergunta do SO:

A ideia é criar uma consulta que será usada como preenchimento automático, mas que moverá os resultados que tiverem a palavra-chave exata para o topo.

A primeira parte da consulta p1 busca por correspondência exata enquanto a última parte p2 busca por qualquer ocorrência de uma substring. Isso significa que o provedor que tem " One " em seu nome será selecionado em uma primeira parte e o provedor que tem " Done " em seu nome será selecionado em uma segunda parte.

O problema é que a segunda parte seleciona itens da primeira parte também.
Por causa disso, tentei adicionar um alias para cada parte da união e também tentei adicionar uma condição adicional à última parte da união:AND p2.id != p1.id

Isso não funcionará com o MySQL:

Erro SQL (1054): Coluna desconhecida 'p1.id' na 'cláusula where'.

Também tentei com HAVING, mas sem sorte.

A questão é: existe uma maneira de obter esse resultado de uma só vez?

SELECT * FROM (

    (SELECT DISTINCT 
        p1.*, 
        1 AS priority, 
        CASE WHEN parent_id IS NULL THEN 1 ELSE 2 END AS is_parent
    FROM provider p1
    WHERE CONCAT(' ', name, ' ') LIKE '% one %'
    LIMIT 100)
    
    UNION  
    
    (SELECT DISTINCT 
        p2.*, 
        2 AS priority, 
        CASE WHEN parent_id IS NULL THEN 1 ELSE 2 END AS is_parent
    FROM provider p2
    WHERE name LIKE '%one%' AND p2.id != p1.id
    LIMIT 100)

    ORDER BY priority, is_parent
    
) AS t LIMIT 100;

Dados de amostra:

ID | Parent ID | Name          
---------------------------
 1 | <NULL> | One dove
 2 |      1 | One play
 3 | <NULL> | Monitor
 4 |      1 | Day one
 5 | <NULL> | Drone
 6 | <NULL> | Screen
 7 | <NULL> | Done with you
 8 | <NULL> | Not done
 9 | <NULL> | All as one

O resultado esperado:

ID | Parent ID | Name           | Priority | Is parent         
------------------------------------------------------
 1 |    <NULL> | One dove       |        1 |         1
 9 |    <NULL> | All as one     |        1 |         1
 2 |         1 | One play       |        1 |         2
 4 |         1 | Day one        |        1 |         2
 5 |    <NULL> | Drone          |        2 |         1
 7 |    <NULL> | Done with you  |        2 |         1
 8 |    <NULL> | Not done       |        2 |         1

Quando TooltipBoxaberto, clicar em qualquer elemento que pode ser composto na tela não tem outro efeito além de descartar o pop-up. Como isso acontece e qual é a maneira eficaz de implementá-lo, não importa onde o Composable atual esteja na árvore de composição quando a Popupestiver aberto, para que nenhum outro Composable Popupreceba quaisquer gestos.

@Preview
@Composable
fun TooltipBoxSample() {
    Column(
        modifier = Modifier.fillMaxSize().border(2.dp, Color.Blue)
    ) {
        Button(
            onClick = {}
        ){
            Text("Some button")
        }

        val state = rememberTooltipState(
            isPersistent = true
        )
        val coroutineScope = rememberCoroutineScope()

        Spacer(modifier = Modifier.height(120.dp))

        Row(
            modifier = Modifier.weight(1f)
        ) {
            Spacer(modifier = Modifier.width(100.dp))

            TooltipBox(
                positionProvider = rememberPlainTooltipPositionProvider(
                    spacingBetweenTooltipAndAnchor = 16.dp
                ),
                state = state,
                tooltip = {

                    PlainTooltip(
                        caretProperties = CaretProperties(
                            caretWidth = 16.dp,
                            caretHeight = 16.dp
                        ),
                        shape = RoundedCornerShape(16.dp),
                        containerColor = Color.Red
                    ) {
                        Text(
                            text = "Tooltip Content for testing...",
                            modifier = Modifier.padding(16.dp)
                        )
                    }

                },
                content = {
                    Icon(
                        modifier = Modifier
                            .size(60.dp)
                            .clickable {
                                coroutineScope.launch {
                                    state.show()
                                }
                            },
                        imageVector = Icons.Default.Info,
                        contentDescription = null
                    )
                }
            )
        }

    }
}

Se você tocar em qualquer lugar da tela com Popupelementos que podem ser compostos, receberá eventos de clique

@Preview
@Composable
fun PopupOpenCloseTest() {

    var showPopup by remember {
        mutableStateOf(false)
    }


    Column(
        modifier = Modifier.fillMaxSize()
    ) {

        Button(
            onClick = {}
        ) {
            Text("Some button")
        }

        Box {
            Icon(
                modifier = Modifier
                    .border(2.dp, Color.Blue)
                    .size(60.dp)
                    .clickable {
                        if (showPopup.not()) {
                            showPopup = true
                        }
                        println("CLICKED showPopup: $showPopup")
                    },
                imageVector = Icons.Default.Info,
                contentDescription = null
            )

            if (showPopup) {
                Popup(
                    offset = IntOffset(300, 300),
                    onDismissRequest = {
                        if (showPopup) {
                            showPopup = false
                        }
                    }
                ) {
                    Box(
                        modifier = Modifier.background(Color.White).padding(16.dp)
                    ) {
                        Text("Popup Content")
                    }
                }
            }
        }

    }
}

Inspecionei o código-fonte do Tooltip e do BasicTooltip , mas não há nenhum lugar onde ele crie uma janela ou visualização que cancele o gesto ou consuma algum.

Eu tenho um mac m2 e estou tentando executar o simulador da apple com alguns módulos de titânio e aparecem os seguintes erros:

[ERROR] Error: The app is using native modules that do not support arm64 simulators and you are on an arm64 device:
- de.marcelpociot.imagefromgif
- ti.safaridialog
- com.movento.splitwindow
- net.iamyellow.tiws
    at iOSBuilder.invokeXcodeBuild (/Users/programador1/Library/Application Support/Titanium/mobilesdk/osx/12.2.1.GA/iphone/cli/commands/_build.js:7096:17)
Process exited with 1

Por favor me ajude.

Os módulos anteriores não possuem atualização para m2 ou pelo menos não encontrei uma atualização recente.

Atualmente, para reinicializar um modelo para AutoModelForSequenceClassification, podemos fazer o seguinte:

from transformers import AutoModel, AutoConfig, AutoModelForSequenceClassification

m = "moussaKam/frugalscore_tiny_bert-base_bert-score"
config = AutoConfig.from_pretrained(m)
model_from_scratch = AutoModel(config)

model_from_scratch.save_pretrained("frugalscore_tiny_bert-from_scratch")

model = AutoModelForSequenceClassification(
  "frugalscore_tiny_bert-from_scratch", local_files_only=True
)

Existe alguma maneira de reinicializar os pesos do modelo sem salvar um novo modelo pré-treinado inicializado com AutoConfig?

model = AutoModelForSequenceClassification(
  "moussaKam/frugalscore_tiny_bert-base_bert-score", 
  local_files_only=True
  reinitialize_weights=True
)

ou algo como:

model = AutoModelForSequenceClassification(
  "moussaKam/frugalscore_tiny_bert-base_bert-score", 
  local_files_only=True
)

model.reinitialize_parameters()

Em consultas onde comparo dados entre 2 tabelas, costumo usar a combinação de COALESCEe FULL OUTER JOINpara exibir registros disponíveis apenas em 1 das tabelas.

Isso pode ser feito com menos açúcar sintático? (Não me refiro a substituir COALESCEpor NVLalgo assim.)

WITH Dataset1 AS (
    SELECT
        id,
        SUM(amount) AS amount
    FROM
        table1
    GROUP BY
        id
),

Dataset2 AS (
    SELECT
        id,
        SUM(amount) AS amount
    FROM
        table2
    GROUP BY
        id
)

SELECT
    COALESCE(d1.id, d2.id) AS ID,
    COALESCE(d1.amount, 0) AS D1_AMOUNT,
    COALESCE(d2.amount, 0) AS D2_AMOUNT,
    COALESCE(d1.amount, 0) - COALESCE(d2.amount, 0) AS DELTA
FROM
    Dataset1 d1
FULL OUTER JOIN
    Dataset2 d2 c ON
        d2.id = d1.id
WHERE
    ABS(COALESCE(d1.amount, 0) - COALESCE(d2.amount, 0)) >= 5
ORDER BY
    ID

Atualmente tenho um array com vários objetos. O loop for faz um conjunto de consultas baseado nos objetos da matriz usando um loop for de um modelo.

search_post = ["1990", "2023"]
for query in search_post:
    vehicle_result = Vehicle.objects.filter(
        Q(title__icontains=query) |
        Q(details__icontains=query) |
        Q(year__icontains=query) |
        Q(notes__icontains=query)
    )
    print('vehicle_result: %s' % vehicle_result)

O problema que estou tendo é que quando o array tem vários itens, ele passa pelo loop for para cada objeto e gera o resultado de cada objeto. Somente o último resultado do objeto será retido se eu chamar essa variável em outro lugar do código.

Exemplo de saída:

vehicle_result: <QuerySet [<Vehicle: BMW>]>
vehicle_result: <QuerySet [<Vehicle: Toyota>, <Vehicle: Mercedes>, <Vehicle: Honda>]>

Quero armazenar/combinar todos eles em uma variável - evitar a perda de todos os resultados (no momento, apenas o último é retido, acho que porque a variável foi substituída)

Como posso conseguir?