All perguntas(coding)

Estou trabalhando em um processo de importação em lote de dados de vários arquivos .csv do meu computador para o Planilhas Google sem fazer upload de todos eles para o Google Drive primeiro.

Atualmente tenho o seguinte:

index.html

<form>
  <input type="file" name="file" onchange="importCsv(this.parentNode)" accept=".csv,text/csv" multiple>
</form>
<p id="progress" style="display:none;">
  <label for="upload" style="font-family: sans-serif;">Uploadling...</label>
  <progress id="upload"></progress>
</p>
<script>
  function readFileAsBuffer(file){
    return new Promise(function(resolve,reject){
      let fr = new FileReader();

      fr.onload = function(){
          resolve(fr.result);
      };

      fr.onerror = function(){
          reject(fr);
      };

      fr.readAsArrayBuffer(file);
    });
  }
  async function importCsv(e) {
    document.getElementById("progress").style.display = "block";
    const files = e.file.files;
    let fileReaders = [];
    let fileValues = [];

    for(let i = 0;i < files.length;i++){ 
      fileReaders.push(readFileAsBuffer(files[i])); 
    }

    await Promise.all(fileReaders).then((values) => {
      fileValues.push(values);

    });

    for(let i=0; i < files.length; i++)
    {
      let file = files[i];
      await google.script.run.withSuccessHandler(google.script.host.close).importCsv([[...new Int8Array(fileValues[0][i])], file.type, file.name]);
    }    
  }
</script>

script.gs

function onOpen() {
  SpreadsheetApp.getUi().createMenu("Import").addItem("Import CSVs", "importCsv").addToUi();
}

function importCsv(e){
  if (!e) {
    SpreadsheetApp.getUi().showModalDialog(HtmlService.createHtmlOutputFromFile("index"), "Import CSVs");
    return;
  }
  const lock = LockService.getScriptLock();
  lock.waitLock(30000);
  const csv = Utilities.parseCsv(Utilities.newBlob(...e).getDataAsString());
  const sheet = SpreadsheetApp.getActiveSheet();
  sheet.getRange(sheet.getLastRow() + 3, 1, csv.length, csv[0].length).setValues(csv);
  lock.releaseLock();
}

Inicialmente, configurei sem usar promessas, mas percebi que todos os arquivos que eu tentava importar eram colocados na planilha fora de ordem. Pensei que usar promessas para esperar até que cada arquivo fosse lido e processado antes de passar para a planilha ajudaria, mas ainda estou com o mesmo problema. Além de usar o objeto LockService, como estou fazendo, alguém tem alguma ideia de como fazer o script esperar até que cada seção seja adicionada à planilha?

Isso parece ser muito simples, mas as funções que tentei não parecem funcionar.

Quero encontrar todas as correspondências de um padrão dentro de uma string, por exemplo, match('killer', 'l')deve retornar 3, 4. Seria bom poder fazer isso com vários padrões de caracteres, mas não é essencial.

O que tentei até agora:

t = 'killer'
p = 'l'

grep(p, t) #returns 1
grep(p, strsplit(t,'')) #also 1 for some reason
stringr::str_match_all(t, p) #gives an array of "l"s.

Não quero criar uma função sozinho porque ela não será otimizada e precisarei executá-la milhares de vezes. Além disso, sinto que definitivamente existe uma função para isso.

Ao transmitir com assistentes OpenAI

openai.beta.threads.messages.create(
    thread_id=thread_id,
    role="user",
    content=payload.question
)

run = openai.beta.threads.runs.create(
    thread_id=thread_id,
    assistant_id=assistant_id,
    stream=True,
    tool_choice={"type": "file_search"},
)

streamed_text = ""
for event in run:
  if event.event == "thread.message.delta":
    delta_content = event.data.delta.content
    if delta_content and delta_content[0].type == "text":
      text_fragment = delta_content[0].text.value
      streamed_text += text_fragment
      yield {"data": text_fragment}
  if event.event == "thread.run.completed":
    break

as citações estão chegando nos formatos como 【4:2†source】ouciteturnXfileY

Como consertar isso?

Tenho um serviço que notifica que um conjunto de categorias foi preenchido (por meio de uma chamada a uma API no bootstrap do aplicativo). Assim que essas categorias estiverem prontas, preciso iniciar uma chamada à API para cada categoria contida no conjunto para encontrar os detalhes dos dados de cada categoria, que serão exibidos em diferentes seções da mesma página.

A notificação pode ocorrer de duas formas diferentes, ao final do primeiro carregamento do aplicativo (lançado apenas uma vez) ou toda vez que um usuário navegando pelo aplicativo chega na página e o array de categorias já foi preenchido.

Este é o código do componente.

export class CategoriesComponent implements OnInit, OnDestroy {
  tagsCategories: TagCategory[]|null = null;
  dateRangeTags: {start: Date, end: Date};
  component_destroy = new Subject<void>();

  constructor(...)
  {
    const d = new Date();
    this.dateRangeTags = {start: this.commonFunc.getOneMonthAgo(d), end: d};
  }

  ngOnInit() {
    console.log('init', this.tagsCategories);
    this.loader.loadingOn();
    if (this.sharedDataService.getTagCategories().length > 0) {
      //categories have already been loaded
      this.sharedData.notifyTagsCategoriesReady();
    }

   
    this.sharedData.categoriesAvailable$
      .pipe(
        tap(() => {
          const categories = this.sharedData.getTagCategories();
          for (const category of categories) {
            category.date_range_request = {...this.dateRangeTags};
          }
          this.tagsCategories = categories;
          console.log('tap side effect', this.tagsCategories);
          this.loader.loadingOff();
        }),
        filter((v,i) => this.tagsCategories !== null && this.tagsCategories.length > 0),
        switchMap(
          () => from(this.tagsCategories!).pipe(
            mergeMap((category: TagCategory) =>
              this.fetchTagsCategories(category.date_range_request!, category)
                .pipe(
                  tap({
                    next: (categories: TagCategory[]) => {
                      if (categories.length > 0) {
                        const cat = categories[0];
                        if (cat.id === category.id) {
                          category.tags_plots = cat.tags_plots;
                        }
                      }
                    },
                    error: (error) => {
                      category.spinner = false;
                    },
                    complete: () => {
                      category.spinner = false;
                    }
                  }),
                  catchError((error) => throwError(() => error))
                )
            )
          )
        )
      )
      .subscribe({
        next: (val) => {
          console.log('final next', val);
        },
        error: (error: string) => {
          this.errorHandler.displayErrorDialog(error);
        },
        complete: () => {}
      })
  }
}

Este é o assunto no serviço e a função que chamo para notificar a disponibilidade das categorias nos dois cenários diferentes.

export class SharedDataService {
  categories: TagCategory[] = [];
  private _categoriesAvailable = new Subject<boolean>();
  categoriesAvailable$ = this._categoriesAvailable.asObservable();
  
  //this is called when the categories are fetched from the server
  setTagCategories(tagCategories: TagCategory[]) {
    this.categories = tagCategories;
    console.log('Set tag categories');
    this._categoriesAvailable.next(true);
  }

  //this is called when the user visit the categories page and the array is already loaded
  notifyTagsCategoriesReady() {
    console.log('notifyTagsCategoriesReady');
    this._categoriesAvailable.next(true);
  }

  getTagCategories() {
    return this.categories;
  }
}

Na visualização de componentes, inseri uma proteção para não exibir as várias seções se o array de categorias ainda não tiver sido inicializado ou estiver vazio.

<h1 class="nom">{{ 'categories.title' | translate }}</h1>
@if (tagsCategories && tagsCategories.length > 0) {
  @for (tagCategory of tagsCategories; track tagCategory.id) {
<!-- build each section -->
}

Quando o aplicativo é completamente recarregado na página de categoria e, em seguida, o aplicativo é inicializado, tudo funciona como deveria, mas se você navegar para outras páginas e retornar a essa página, as várias seções não são mostradas, mesmo que o console.log no operador tap indique que o array está preenchido corretamente. Além disso, toda vez que você revisita a página, as solicitações se multiplicam como se a mesma assinatura fosse adicionada a cada vez; se o array contiver três elementos, toda vez que eu revisito a página, 3 solicitações são adicionadas. Também tentei inserir um takeUntil notificando a destruição do componente, mas nesse caso a assinatura só funciona na primeira vez e nunca é recriada depois, mesmo que o console.log dentro da função ngOnInit seja impresso.

É claro que estou esquecendo de muitas coisas e talvez existam implementações melhores para conseguir o que preciso fazer, mas ficaria grato se alguém pudesse me dizer por que o Angular parece ignorar a mudança de estado do array ao não mostrar as várias seções após o primeiro carregamento e, acima de tudo, por que as solicitações se multiplicam toda vez que visito a página.

Sigo o tutorial do Azure sobre como ajustar o GPT. Sigo a fase de implantação.

Código:

# Deploy fine-tuned model

import json
import requests

token = '[redacted]'
subscription = '[redacted]'
resource_group = "[redacted]"
resource_name = "[redacted]"
model_deployment_name = "gpt-4o-mini-2024-07-18-ft" # Custom deployment name you chose for your fine-tuning model

deploy_params = {'api-version': "2023-05-01"}
deploy_headers = {'Authorization': 'Bearer {}'.format(token), 'Content-Type': 'application/json'}

deploy_data = {
    "sku": {"name": "standard", "capacity": 1},
    "properties": {
        "model": {
            "format": "OpenAI",
            "name": "gpt-4o-mini-2024-07-18.ft-[redacted]", #retrieve this value from the previous call, it will look like gpt-4o-mini-2024-07-18.ft-[redacted]
            "version": "1"
        }
    }
}
deploy_data = json.dumps(deploy_data)

request_url = f'https://management.azure.com/subscriptions/{subscription}/resourceGroups/{resource_group}/providers/Microsoft.CognitiveServices/accounts/{resource_name}/deployments/{model_deployment_name}'

print('Creating a new deployment...')

r = requests.put(request_url, params=deploy_params, headers=deploy_headers, data=deploy_data)

print(r)
print(r.reason)
print(r.json())

Isso funciona bem, mas o token expira rapidamente. Isso me incomoda. Como posso implantar um modelo GPT ajustado no Azure via Python sem usar um token (por exemplo, usando uma chave de endpoint)?

considere este exemplo (aqui com mais dados de amostra no editor vega )

{
  "$schema": "https://vega.github.io/schema/vega-lite/v6.json",
  "data": {
    "name": "dataset",
    "values": [
    {
        "JobBeg": "2023-01-01T11:04:45",
        "JobEnd": "2023-01-01T18:04:45",
        "JobNum": "JN000",
        "Assigned_To": "David",
        "Midpoint": "2023-01-01T14:34:45"
    },
    {
        "JobBeg": "2023-01-01T15:07:31",
        "JobEnd": "2023-01-01T18:07:31",
        "JobNum": "JN001",
        "Assigned_To": "Bob",
        "Midpoint": "2023-01-01T16:37:31"
    }
]    
  },
  "layer": [
    {
      "mark": {"type":"bar", "stroke":"black","strokeWidth":2},
      "encoding": {
        "y": {
          "field": "Assigned_To",
          "type": "nominal",
          "title": "Assigned To"
        },
        "x": {
          "field": "JobBeg",
          "type": "temporal",
          "title": "Start Time",
          "axis":
          {
            "interval": "day",
            "step": 1
          }
        },
        "x2": {
          "field": "JobEnd",
          "title": "End Time"
        },
      "tooltip": [
        {
          "field": "JobBeg",
          "type": "temporal",
          "title": "Start Time",
          "format": "%Y-%m-%d %H:%M"
        },
        {
          "field": "JobEnd",
          "type": "temporal",
          "title": "End Time",
          "format": "%Y-%m-%d %H:%M"
        },
        {
          "field": "JobNum",
          "type": "nominal"
        }
      ]
      }
    },
    {
      "mark": {
        "type": "text",
        "align": "center",
        "baseline": "middle"
      },
      "encoding": {
        "y": {
          "field": "Assigned_To",
          "type": "nominal"
        },
        "x": {
          "field": "Midpoint",
          "type": "temporal"
        },
        "text": {
          "field": "JobNum",
          "type": "nominal"
        }
      }
    }
  ]
}

atualmente, estou usando o ponto médio do início/fim de um trabalho para centralizar a marca de texto em cada barra, mas não consigo descobrir uma maneira de restringir a marca de texto ao tamanho da barra (por exemplo, se for uma duração muito curta, não devo ver o texto transbordar da barra)

Tenho uma Planilha Google onde as pessoas inserem suas informações de viagem. A tabela é mais ou menos assim:

Várias linhas abaixo e várias colunas acima, em um espaço vazio, gostaria de ordená-los da data/hora de chegada mais antiga para a mais recente, e preciso apenas de Nome, Data de Chegada e Hora de Chegada. Então, na outra área, ficaria assim:

(Maude pode estar no começo, no fim ou não ser exibida, já que suas informações de viagem não foram inseridas).

Estou com dificuldades para combinar as colunas "Data de Chegada" e "Hora de Chegada" em uma "Data e Hora" utilizável para classificar as linhas com a função SORT, especialmente porque são apenas texto livre. Classificar pela data de chegada funciona, mas depois de lidarmos com os horários, a classificação é feita em ordem alfabética. Portanto, "Rod" apareceria incorretamente antes de "Ned" neste exemplo.

Tenho o código abaixo:

$xxx = shell_exec('sudo chown -R user:user "/temp123" 2>&1');

Funciona muito bem, quer dizer, o usuário/grupo está definido corretamente.

Mas o problema é que quando eu coloco echoa variável $xxxela parece vazia, mas não está.

Por exemplo, o código:

echo '|' . $xxx . '|'; 

Retorna ||. Também o código:

echo strlen($xxx); 

Retorna 0. No entanto, se eu tentar este código:

if ($temp1122 !== '') {
    
    echo 'is not empty';
    
}

Ele sempre retorna is not empty. Tentei ecoar, $xxx[0]mas o PHP retorna um erro dizendo que não há nenhum caractere naquele índice. Então, o que está acontecendo? Acho que algum caractere de controle está sendo retornado por , shell_execmas deveria mudar strlenou ficar uniforme, [0]certo?

O método addData do IgniteDataStreamer afirma que "Este método pode ser chamado de várias threads em paralelo para acelerar o streaming, se necessário". Gostaria de saber se também é seguro usar várias instâncias do IgniteDataStreamer para transmitir dados para o mesmo cache simultaneamente?

Meu caso de uso é que estou tentando otimizar o pré-carregamento de um cache grande após a inicialização do meu cluster Ignite. Estou começando com algo assim:

try (IgniteDataStreamer<K, V> streamer = ignite.dataStreamer("MyCache")) {
    try (Stream<Map.Entry<K, V>> stream = jdbcTemplate.queryForStream(
            "select * from foo where '2020-01-01'<=foo.time and foo.time<'2026-01-01'",
            MY_ROW_MAPPER)) {
        stream.forEach(entry -> streamer.addData(entry.getKey(), entry.getValue()));
    }
}

O que eu gostaria de fazer é dividir isso em N tarefas (IgniteRunnables), cada uma responsável por carregar/transmitir (por exemplo) dados de um mês para o cache. Em seguida, eu distribuiria as tarefas uniformemente pelo meu cluster, enviando-as para a API de computação do Ignite, e esperaria até que todas fossem concluídas.

Minha tentativa inicial parece funcionar bem, exceto pelo fato de que às vezes vejo avisos em meus logs como este após o pré-carregamento do cache terminar:

(Log4J2Logger.java:523) A validação dos estados da partição falhou para o grupo: MyCache, msg: Os contadores de atualização das partições são inconsistentes para a parte...

Pelo que posso perceber, esse registro é acionado por um evento de troca de mapa de partição (PME) que ocorre quando um IgniteAtomicLong não relacionado é inicializado pela primeira vez.

O código abaixo produz -

Erro (10327): erro VHDL em XXXX.vhd(1581): não é possível determinar a definição do operador ""&"" -- encontradas 47 definições possíveis Erro (10647): erro de inferência de tipo VHDL em XXXX.vhd(1581): o tipo de expressão é ambíguo - "std_logic_vector" ou "slvn_array" são duas correspondências possíveis Erro (10411): erro de conversão de tipo VHDL em XXXX.vhd(1581): não é possível determinar o tipo de objeto ou expressão próximo ao texto ou símbolo "UNSIGNED"

----CODE
usb_hid_phy_offload_address         <= std_logic_vector(unsigned(ENDPOINT0_CTRL_REG) + unsigned((("00000") & (cfg_hid_ep(v_selp)(5 downto 0)) & ("00"))));
---END CODE

Tentei todas as combinações que me vêm à mente. Sugestões são bem-vindas.

constant g_num_usbs  : integer range 1 to 8 := 2 ;
type     slvn_array is array (natural range <>) of  std_logic_vector ;

signal usb_hid_phy_offload_address : std_logic_vector(12 downto 0) ;
constant ENDPOINT0_CTRL_REG        : std_logic_vector(12 downto 0) := '0' & x"040" ;
signal cfg_hid_ep : slvn_array(g_num_usbs-1 downto 0)( 7 downto 0)  ;