All perguntas(coding)

Vamos imaginar que eu tenha uma função. É uma função muito boa, muito amigável. E ela recebe um argumento, vamos chamá-la de type. Mas adivinhe? Na verdade, é uma string! Deixe-me dar um exemplo:

function returnWithType(o: any, type: 'string' | 'number') {
  if (typeof o === type) return o
  throw new Error(`AHHHH!!!!!`)
}

Viu o que eu fiz? Comparei o tipo com o tipo!

Mas, ok, agora deixe-me perguntar isto... como posso especificar o tipo de retorno real da função , de modo que se eles passarem "string", o tipo de retorno seja string, e o mesmo para number , mas "number"em vez de "string"assumir que eles passaram o valor da string "number"para o segundo parâmetro neste caso???

Eu basicamente quero isso:

function returnWithType(o: any, type: 'string' | 'number'):
  asserts typeof o === as // <---- THIS
{
  // ...
}

Ou talvez isto:

function returnWithType(...):
  type extends 'string' ? string :
  type extends 'number' ? number :
  boolean
{
  // ... solves world hunger ...
}

Acabei de perceber que posso fazer isso criando o genérico T extends ...e retornando um ternário baseado em T, mas existe alguma maneira mais limpa , talvez com alguns builtins inteligentes, de derivar essas informações automaticamente???

Criei um módulo "persist" contendo uma função obj_pickle que estou usando para conservar vários objetos no meu projeto. Funciona bem, mas está falhando no pytest, retornando:

>           pickle.dump(obj, file_handle, protocol=protocol)
E           AttributeError: Can't pickle local object 'test_object.<locals>.TestObject'

Correndo:

• python 3.12
• Versão do pytest: 8.3.5

Vejo que há problemas semelhantes relacionados ao multiprocessamento, mas não acho que o PyTest esteja expondo esse problema. Código abaixo, e muito obrigado.

# lib.persist.py
from pathlib import Path
import pickle


def obj_pickle(obj: object, dir:Path, protocol: int = pickle.HIGHEST_PROTOCOL) -> None:
    """
    Pickle an object to a byte file.
    """
    if not dir.exists():
        dir.mkdir(parents=True, exist_ok=True)
    path = Path(dir, obj.instance_name + '.pkl')
    with open(path, "wb") as file_handle:
        pickle.dump(obj, file_handle, protocol=protocol)
    print(f"{obj.__class__.__name__} object {obj.instance_name} saved to {path}")

# tests.test_persist.py
from pathlib import Path

import pytest

from lib.persist import obj_pickle

TEST_DIR = Path("test_dir")


@pytest.fixture
def test_object():
    class TestObject():
        def __init__(self, instance_file_name):
            self.instance_file_name = instance_file_name
            self.data = "This is a test object."

    test_object = TestObject("test_object_file")
    
    return test_object


def test_obj_pickle(test_object):
    obj_pickle(test_object, Path(TEST_DIR))
    path = Path(TEST_DIR, "test_object_file" + ".pkl")
    assert path.exists()

Tenho uma coluna que possui valores como abaixo:

x <- c(23, 17, 25, 22, 21, 51, 22, NA, 62, 27, NA, NA, 27, 50, NA, 
NA, 22, 19, 27, 27, NA, 25, NA, NA, 25)

Quero criar uma nova coluna que indique se o valor na coluna acima até aquela linha é o valor máximo até o momento.

Portanto, para a primeira linha, a nova entrada de coluna será 1, já que 23 é o primeiro valor mais alto.

A segunda linha na nova coluna será 0, pois 17 não é o máximo de 23 17

A terceira linha na nova coluna será 1, já que 25 é o máximo de 23 17 25

E assim por diante...

A nova coluna deve ser como

1 0 1 0 0 1 0 .. 

Não tenho certeza de como fazer isso. Posso pensar em loops, mas deve haver uma maneira mais clara.

Os NA devem ser mantidos

Eu criei este código para internar strings e manipular &'staticreferências a elas.

Acredito que seja verdade, mas gostaria de ter uma confirmação disso.

Minha justificativa é a seguinte:

• O HashSeté alocado estaticamente e não causa realocação de seus valores (seu armazenamento interno pode ser realocado, mas o Stringpróprio não deve).
• Qualquer inserção é protegida pelo Mutex.
• Como eles Stringnunca são removidos do HashSet, transmuteo envio do conteúdo deles &'staticdeve ser seguro.

use std::{collections::HashSet, sync::Mutex};

lazy_static! {
    static ref LOCKED_HASH: Mutex<HashSet<String>> = Mutex::new(HashSet::new());
}

pub fn intern_string(input: &str) -> &'static str {
    let mut lock = LOCKED_HASH.lock().unwrap();
    if let Some(val) = lock.get(input) {
        unsafe { std::mem::transmute::<&str, &'static str>(val) }
    } else {
        lock.insert(input.to_string());
        let interned = lock.get(input).unwrap();
        unsafe { std::mem::transmute::<&str, &'static str>(interned) }
    }
}

Isso é realmente seguro?

Tentando implantar minha função de nuvem do Firebase e estou recebendo o seguinte erro:

Erro: Não é possível encontrar a região do bucket de armazenamento

A função que estou tentando implementar se parece com:

import {initializeApp} from "firebase-admin/app";
import {getStorage} from "firebase-admin/storage";
import {getFirestore} from "firebase-admin/firestore";
import {logger} from "firebase-functions";
import {onDocumentDeleted} from "firebase-functions/v2/firestore";
import {onObjectFinalized} from "firebase-functions/v2/storage";

initializeApp();

export const onThumbUploaded = onObjectFinalized(
  {
    bucket: "<MY_PROJECT_ID>.appspot.com",
    region: "us-central1",
  },
  async (event) => {
    //... rest of my code...
  });

Não consegui encontrar nada sobre esse assunto no Google ou no AI-Tools.

A ideia básica é que eu queira que o texto "Carregando" seja exibido enquanto o componente filho estiver carregando dados e, em seguida, desapareça quando terminar. Mas como o componente pai pode saber quando o filho terminou de carregar os dados?

Meu pai se parece com isso:

<div *ngIf="isLoadingFlg">Loading...</div>

<router-outlet></router-outlet>

De alguma forma, preciso que o componente filho consiga definir o componente pai isLoadingFlg. O componente filho se parece com isto:

ngOnInit() {
  this.isLoadingFlg = true;
  setTimeout(() => {
    this.isLoadingFlg = false;
  }, 1000);
}

Eu usei tailwind.config.jsassim:

export default {
  theme: {
    extend: {
      fontSize: {
        'heading-banner-title': ['88px', { lineHeight: '100px', fontWeight: '700' }],
      },
    },
  },
};

Agora quero usar a mesma configuração no Tailwind v4, mas usando @theme:

@theme {
  --text-heading-banner-title: 88px; /* I also want to add line-height and font-weight */
}

Anteriormente, eu estava usando o seguinte estilo:

.text-heading-banner-title {
  @apply text-[88px] leading-[100px] font-bold;
}

Entretanto, ao usar essa abordagem, prefixos responsivos (por exemplo, sm:text-heading-banner-title) não funcionam como esperado.

Quero me especializar std::formatterdentro do meu namespace. No entanto, isso não funciona como eu gostaria (variante 1). Funciona fora do namespace (variante 3), bem como com uma solução alternativa dentro do namespace (variante 2).

#include <format>
#include <iostream>
#include <string>
#include <type_traits>

class Class {};

#define VARIANT 1

namespace Namespace {

#if VARIANT == 1
template <>
struct std::formatter<Class> : std::formatter<std::string> {
    auto format(const Class& Class, auto& context) const {
        return std::formatter<std::string>::format("CLASS", context);
    }
};
#endif

#if VARIANT == 2
template <typename T>
    requires std::same_as<T, Class>
struct std::formatter<T> : std::formatter<std::string> {
    auto format(const Class& Class, auto& context) const {
        return std::formatter<std::string>::format("CLASS", context);
    }
};
#endif

}  // namespace Namespace

#if VARIANT == 3
template <>
struct std::formatter<Class> : std::formatter<std::string> {
    auto format(const Class& Class, auto& context) const {
        return std::formatter<std::string>::format("CLASS", context);
    }
};
#endif

int main() { std::cout << std::format("{}", Class()) << std::endl; }

Isto está no x64 msvc v19.40 VS17.10. gcc compila apenas a variante 3.

Então, minhas perguntas são: quais são as formas portáteis e em conformidade com os padrões de especialização std::formatterdentro de namespaces (ou em geral)?

Tenho um dataframe Pandas df. Ele possui múltiplos índices com Gx.Region e Scenario_Model. O índice Scenario_Model é ordenado em ordem alfabética: des, pes, tes. Quando o ploto, ele aparece na mesma ordem. No entanto, quero reordená-lo como pes, tes e des, e plotá-lo de acordo. É possível fazer isso no dataframe Pandas em Python?

    dict = {('Value', 2023, 'BatteryStorage'): {('Central Africa', 'des'): 0.0,
  ('Central Africa', 'pes'): 0.0,
  ('Central Africa', 'tes'): 0.0,
  ('Eastern Africa', 'des'): 0.0,
  ('Eastern Africa', 'pes'): 0.0,
  ('Eastern Africa', 'tes'): 0.0,
  ('North Africa', 'des'): 0.0,
  ('North Africa', 'pes'): 0.0,
  ('North Africa', 'tes'): 0.0,
  ('Southern Africa', 'des'): 504.0,
  ('Southern Africa', 'pes'): 100.0,
  ('Southern Africa', 'tes'): 360.0,
  ('West Africa', 'des'): 0.0,
  ('West Africa', 'pes'): 0.0,
  ('West Africa', 'tes'): 0.0},
 ('Value', 2023, 'Biomass PP'): {('Central Africa', 'des'): 0.0,
  ('Central Africa', 'pes'): 0.0,
  ('Central Africa', 'tes'): 0.0,
  ('Eastern Africa', 'des'): 40,
  ('Eastern Africa', 'pes'): 10,
  ('Eastern Africa', 'tes'): 50,
  ('North Africa', 'des'): 0.0,
  ('North Africa', 'pes'): 0.0,
  ('North Africa', 'tes'): 0.0,
  ('Southern Africa', 'des'): 90.0,
  ('Southern Africa', 'pes'): 43.0,
  ('Southern Africa', 'tes'): 50.0,
  ('West Africa', 'des'): 200.0,
  ('West Africa', 'pes'): 150.0,
  ('West Africa', 'tes'): 100}}

df_sample = pd.DataFrame.from_dict(dict)
df_sample.plot(kind = "bar",
               stacked = True)

CodePen: https://codepen.io/C3ISR-Everything-Cybersecurity/pen/azbeOEK

o que estou tentando fazer é ter um pouco de animação ou transição revelada quando o usuário clica no acordeão para exibir a tabela, código completo abaixo HTML CSS JS, quero animar a transição de abertura e fechamento das tabelas no acordeão.

Código completo:

HTML:

            var acc = document.getElementsByClassName("accordion");
            var i;

            for (i = 0; i < acc.length; i++) {
                acc[i].addEventListener("click", function() {
                    this.classList.toggle("active");
                    var panel = this.nextElementSibling;
                    if (panel.style.display === "block") {
                        panel.style.display = "none";
                    } else {
                        panel.style.display = "block";
                    }
                });
            }

       body {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
            background-color: White;
            font-family: Sakkal Majalla;
            direction: rtl;
            position: relative;
            z-index: -2;
            -ms-overflow-style: none;
            
        }
        body::-webkit-scrollbar, body::-webkit-scrollbar-button { display: none; } /* Chrome */


        li {
            list-style: none;
        }

        a {
            text-decoration: none;
        }

        .main{    
            display: grid;
            grid-template-columns: 1fr;
            justify-items: center;
            margin-top: 2rem;
            margin-bottom: 1rem;
        }

        table {
            border: 1px solid #dededf;  
            table-layout: fixed;
            border-collapse: collapse;
            border-spacing: 1px;
            text-align: center;
        }

        th {
            border: 1px solid #dededf;
            background-color: #eceff1;
            color: #000000;
            padding: 5px;
        }

        td {
            border: 1px solid #dededf;
            background-color: #ffffff;
            color: #000000;
            padding: 5px;  
        }
        th:nth-child(1) {  
            width: 30.9rem;
        }

        th:nth-child(2) {  
            width: 10rem;
        }
        th:nth-child(3) {  
            width: 7rem;
        }

        .accordion {
            background-color: #ffffff;
            color: black;
            font-weight: bold;
            cursor: pointer;
            margin-top: 20px;
            padding: 18px;
            border: none;
            text-align: right;
            outline: none;
            font-size: 20px;
            transition: 0.4s;
            width: 50rem;
            border: 1px solid rgb(219, 219, 219);
            border-radius: 8px;
            box-shadow: rgba(100, 100, 111, 0.123) 0px 7px 29px 0px;
        }

        .active, .accordion:hover {
            border-radius: 8px 8px 0px 0px;
            border-color:  rgb(0, 128, 255);
        }

        .accordion span{
            float: left;
            font-size: 15px;
            color: #116ce4;
        }

        .panel {
            display: none;
            overflow: hidden;  
        }

   <div class="main">
            <button class="accordion">
                John Doe
            </button>
            <div class="panel">
                <table>
                    <th>company</th>
                    <th>department</th>
                    <th>2025?</th>
                    <tr>
                        <td>COMPANY A</td>
                        <td>FINANCE</td>
                        <td>&#9989;</td>
                    </tr>
                    <tr>
                        <td>COMPANY Z</td>
                        <td>PMO</td>
                        <td>&#10060;</td>
                    </tr>
                </table>
            </div>
                 <button class="accordion">
                John Doe
            </button>
            <div class="panel">
                <table>
                    <th>company</th>
                    <th>department</th>
                    <th>2025?</th>
                    <tr>
                         <td>company A</td>
                        <td>HR</td>
                        <td>&#10060;</td>
                    </tr>
                    <tr>
                       <td>company B</td>
                        <td>HR</td>
                        <td>&#10060;</td>
                    </tr>
                    <tr>
                          <td>company C</td>
                        <td>HR</td>
                        <td>&#10060;</td>
                    </tr>
                </table>
            </div>
                 <button class="accordion">
                John Doe
            </button>
            <div class="panel">
                <table>
                    <th>company</th>
                    <th>department</th>
                     <th>2025?</th>
                    <tr>
                        <td>company A</td>
                        <td>HR</td>
                        <td>&#9989;</td>
                    </tr>
                </table>
            </div>       
    </div>