"Unexpected Token" error with v4 and code-surfer

👋 Hey there!
I just threw together a sample project with v4/gatsby and code-surfer@v3. When I attempted to run gatsby develop I got this error
> gatsby develop

success open and validate gatsby-configs - 0.076s
success load plugins - 0.366s
success onPreInit - 0.012s
info One or more of your plugins have changed since the last time you ran Gatsby. As
a precaution, we're deleting your site's cache to ensure there's no stale data.
success initialize cache - 0.045s
success copy gatsby files - 0.234s
success onPreBootstrap - 0.029s
success createSchemaCustomization - 0.004s
success source and transform nodes - 0.993s
success building schema - 0.344s
success createPages - 0.149s
success createPagesStatefully - 0.045s
success onPreExtractQueries - 0.002s
success update schema - 0.050s
success extract queries from components - 0.270s
success write out requires - 0.042s
success write out redirect data - 0.003s
success onPostBootstrap - 0.004s

info bootstrap finished - 5.281 s

success run queries - 0.051s - 3/3 59.38/s

 ERROR #98123  WEBPACK

Generating SSR bundle failed

Unexpected token (12:2)

File: node_modules/@mdx-deck/gatsby-plugin/src/index.js:12:2

It seems to be related to code-surfer, though the error being printed is pointing to mdx-deck, so I figured I'd open an issue here and on code-surfer's repo.
Below is a sample project that should be able to recreate the error.
Sample Project: https://github.com/mhartington/mdx-deck-v4-issue

It seems to be a problem when using gatsby-theme-mdx-deck and importing a component that imports something from mdx-deck.
For example, this deck fails:
import Component from "./component"

## Hi

When component.js imports something from  mdx-deck:
// component.js
import React from "react";
import { useSteps } from "mdx-deck";

export default props => {
  const length = 4;
  const step = useSteps(length);

  return (
    <h2>
      The current step is {step}/{length}
    </h2>
  );
};

I'm getting the same error, but now i'm noticing yarn is giving me this error after adding gatsby-theme-mdx-deck:
error An unexpected error occurred: "could not find a copy of gatsby to link in <proj_path>/node_modules/gatsby-theme-mdx-deck/node_modules".

So I sort of fixed it so far. I was getting an error about webpack, so I added a silly webpack rule (sorry I don't really know what I'm doing):
exports.onCreateWebpackConfig = ({ actions, loaders, getConfig }) => {
  const config = getConfig()
  config.module.rules = [
    ...config.module.rules,
    {
      ...loaders.js(),
      test: /\.js?$/,
      // Exclude all node_modules from transpilation, except for 'swiper' and 'dom7'
      exclude: modulePath =>
        /node_modules/.test(modulePath) &&
        !/node_modules\/(@mdx-deck\/gatsby-plugin\/src)/.test(modulePath),
    },
  ]
  // This will completely replace the webpack config with the modified object.
  actions.replaceWebpackConfig(config)
}

CodeSurfer isn't working entirely right, but at least it's compiling.

Okay, downgrading to v3 solved my CodeSurfer problems, at least.
I think it's something to do with the gatsby theme, because in a standalone, CodeSurfer and v4 work fine together.


Add new chrysalis transaction history API

This new API enables us to get rid of the chrysalis version of chronicle.
It doesn't support pagination, but who is clicking through more than 50 pages anyway?
And it should be quite fast compared to chronicle.
BTW: we could add a CSV export with all results quite easily this way, which makes more sense than showing so many pages.

There seems to be a little problem :pleading_face:  https://github.com/iotaledger/inx-api-core-v1/issues/17


Draft: Merge tags from Feature and Rule with Scenario on filtering (#156)

Part of #156
Synopsis
Godog and Behave cucumber implementations merge tags from Feature and Rule with Scenario on filtering.
Solution
Follow other implementations and merge tags too.
Checklist

Created PR:

[x] In draft mode
[x] Name contains Draft:  prefix
[x] Name contains issue reference
[x] Has assignee

[x] Documentation is updated (if required)
[x] Tests are updated (if required)
[x] Changes conform code style
[ ] CHANGELOG entry is added (if required)
[ ] FCM (final commit message) is posted

[ ] and approved

[ ] Review is completed and changes are approved
Before merge:

[ ] Milestone is set
[ ] PR's name and description are correct and up-to-date
[ ] Draft:  prefix is removed
[ ] All temporary labels are removed

FCM
Merge tags from `Feature` and `Rule` with `Scenario` on filtering with `--tags` CLI option (#166, #156)


Sync template with project

:bug: Bug fix
Changes have fallen out of sync between the project and the template, and vice versa.

:white_check_mark: Checklist

[x] Following CODE_OF_CONDUCT.md.
[x] Checked for duplicate pull requests
[x] Title is a summary of the change, in present tense, ideally < 50 characters
[x] Pulling from a branch (right side), not master.
[x] Pulling into master branch (left side).
[x] Changed relevant files in templates directory.
[x] Fixing a bug? An open bug report exists.
[x] Breaking API changes? Migration notes attached.
[x] Ready for review

:tada: This PR is included in version 3.8.0 :tada:
The release is available on:

npm package (@latest dist-tag)
GitHub release

Your semantic-release bot :package::rocket:


matplotlib intellisense issues / upgrade python-type-stubs

 Environment data

Language Server version: 2022.8.21
OS and version: linux x64
Python version (and distribution if applicable, e.g. Anaconda): 3.9.12 Miniconda
python.analysis.indexing: null
python.analysis.typeCheckingMode: strict

 Code Snippet
Following https://code.visualstudio.com/docs/datascience/data-science-tutorial#_prepare-the-data:
import seaborn as sns
import matplotlib.pyplot as plt

fig, axs = plt.subplots(ncols=5, figsize=(30,5))
sns.violinplot(x="survived", y="age", hue="sex", data=data, ax=axs[0])

You get false positive error squiggles:
(variable) axs: Axes
"__getitem__" method not defined on type "Axes"

Also reported by someone here: https://discourse.matplotlib.org/t/getitem-method-not-defined-on-axes/22651
The type stubs for this got improved 4 months ago in https://github.com/microsoft/python-type-stubs/commit/3e00ef77e0e8727d8512d34a7a489062ea3c5329.
I checked ~/.vscode-server/extensions/ms-python.vscode-pylance-2022.8.21/dist/bundled/stubs/matplotlib/pyplot.pyi to confirm it's the old version.
So those should definitely be updated.
Manual upgrade test
cd ~/.vscode-server/extensions/ms-python.vscode-pylance-2022.8.21/dist/bundled/stubs/
wget https://github.com/microsoft/python-type-stubs/archive/refs/heads/main.tar.gz -O - | tar xvz --strip-components=1

It does pick up the new definitions but there are new problems:
(variable) axs: Axes | ndarray[Unknown, Unknown]
"__getitem__" method not defined on type "Axes" [reportGeneralTypeIssues]

(variable) axs: Axes | ndarray[Unknown, Unknown]
Type of "axs" is partially unknown
  Type of "axs" is "Axes | ndarray[Unknown, Unknown]" [reportUnknownVariableType]

Type of "subplots" is partially unknown
  Type of "subplots" is "Overload[(nrows: Literal[1] = ..., ncols: Literal[1] = ..., *, sharex: bool | Literal['none', 'all', 'row', 'col'] = ..., sharey: bool | Literal['none', 'all', 'row', 'col'] = ..., squeeze: Literal[True] = ..., subplot_kw: Dict[Any, Any] | None = ..., gridspec_kw: Dict[Any, Any] | None = ..., **fig_kw: Any) -> Tuple[Figure, Axes], (nrows: int = ..., ncols: int = ..., *, sharex: bool | Literal['none', 'all', 'row', 'col'] = ..., sharey: bool | Literal['none', 'all', 'row', 'col'] = ..., squeeze: Literal[False], subplot_kw: Dict[Any, Any] | None = ..., gridspec_kw: Dict[Any, Any] | None = ..., **fig_kw: Any) -> Tuple[Figure, ndarray[Unknown, Unknown]], (nrows: int = ..., ncols: int = ..., *, sharex: bool | Literal['none', 'all', 'row', 'col'] = ..., sharey: bool | Literal['none', 'all', 'row', 'col'] = ..., squeeze: bool = ..., subplot_kw: Dict[Any, Any] | None = ..., gridspec_kw: Dict[Any, Any] | None = ..., **fig_kw: Any) -> Tuple[Figure, Axes | ndarray[Unknown, Unknown]]]" [reportUnknownMemberType]

Because pyplot.pyi now contains:
def subplots(........) -> Tuple[Figure, Union[Axes, ndarray]]: ...
Expected type arguments for generic class "ndarray" [reportMissingTypeArgument]

class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]):

So it looks like the stubs need further fixes.
But maybe also pylance/pyright to handle cases like Axes | ndarray[Unknown, Unknown] better?

It also seems to pick up numpy type definitions from my 3.10 system installation rather than the conda environment active in my Jupyter notebook. I hope that's not interfering here.
Long operation: analyzing: /usr/lib/python3/dist-packages/numpy/__init__.pyi (4745ms)

adding a narrowing check seems to fix the __getitem__  issue
from matplotlib.axes import Axes
import seaborn as sns
import matplotlib.pyplot as plt

import pandas as pd
import numpy as np
data = pd.read_csv('titanic3.csv')

fig, axs = plt.subplots(ncols=5, figsize=(30,5))
if isinstance(axs, np.ndarray):
    sns.violinplot(x="survived", y="age", hue="sex", data=data, ax=axs[0])

hmm. maybe the stub for Axes needs updating too so that it has __getitem__.. i see its base class has it
https://github.com/matplotlib/matplotlib/blob/1efc391434812f0f24392ca4a45c5cd846f46862/lib/matplotlib/axes/_base.py#L1378

adding __getitem__ here
/bundled/stubs/matplotlib/axes/_base.pyi
class _AxesBase:
    def __getattr__(self, name: str) -> Any: ...  # incomplete
    def __getitem__(self, key): ... # incomplete

hmm. maybe the stub for Axes needs updating too so that it has __getitem__.. i see its base class has it https://github.com/matplotlib/matplotlib/blob/1efc391434812f0f24392ca4a45c5cd846f46862/lib/matplotlib/axes/_base.py#L1378

That's a method of class ArtistList, not AxesBase!
I think the subplots return type is wrong. If there's only 1 subplot and squeeze is True, Axes is correct. In all other cases it should be ndarray[Axes], not Union[Axes, ndarray].

This issue still seems to be persistent  in the Matplotlib 3.9.1

This issue still seems to be persistent in the Matplotlib 3.9.1

@danieltomasz, please file a new issue describing what you're seeing. This issue is almost two years old and therefore unlikely to be related to what you're seeing today.
Note that starting with version 3.8, matplotlib is now py.typed and therefore our bundled matplotlib stubs should be ignored and have no impact on your experience. The issue you're seeing may therefore be a matplotlib issue.

@debonte  I am really sorry, I was trying comment on matplotlib issue thread, I don't know why I  Ianded here :(


add: instruction for different binaries

Added setting-up instruction for amd64 machine

Hi @DannyS03 , made the changes as suggested

Thanks @swarna1101 - I believe this would work but would double check with repo maintainer.


Pass additional encodings to TableProvider instead of context

@a10y

what i was getting at was, wouldn't it make more sense to just apply the SamplingCompressor encodings by default?

hm, the dependency chain is a bit annoying. vortex-datafusion doesn't depend on the compressor right now. We might say fuck it and add it or keep it as is in this pr

ah, you're right. yea i was hoping there was a way to zero-args load a vortex file for the 99% of cases where that applies, maybe something to change in the future.
i think passing in an explicit context is fine for now in that case, so maybe don't need this PR

I think we can provide some top level crate that aggregates all the available encodings and we can put a list there but still passing things around is weird


Parse PassportData

Interface with parameters header in table.
https://core.telegram.org/bots/api#passportdata

@valscion @Piterden Can you try?

I don't have time right now to try, sorry

Hm. I will try to find some time...

let el = document.getElementById('telegram-passport').parentElement
let code = []
let cls = ''

while (el.nextElementSibling && el.nextElementSibling.tagName !== 'H3') {
  if (el.nextElementSibling.tagName === 'H4') {
    cls = cls + `class ${el.nextElementSibling.innerText}`
  }

  if (el.nextElementSibling.tagName === 'P') {
    cls = `/**${el.nextElementSibling.innerText.replace(/(.{1,72}\s)\s*?/g, '\n * $1')}
 */\n${cls}`
  }

  if (el.nextElementSibling.tagName === 'TABLE') {
    code.push(cls);
    cls = '';
  }

  el = el.nextElementSibling;
}

console.log(code.join('\n\n'))

It has the WIP status for now...

Second version
el = document.getElementById('telegram-passport').parentElement
code = []
cls = ''

while (el.nextElementSibling && el.nextElementSibling.tagName !== 'H3') {
  if (el.nextElementSibling.tagName === 'H4') {
    cls = cls + `class ${el.nextElementSibling.innerText}`
  }

  if (el.nextElementSibling.tagName === 'P') {
    cls = `/**${el.nextElementSibling.innerText.replace(/(.{1,72}\s)\s*?/g, '\n * $1')}
 */\n` + cls
  }

  if (el.nextElementSibling.tagName === 'TABLE') {
    code.push(`${cls}\n{`)
    cls = ''
    const keys = Array.from(el.nextElementSibling.querySelectorAll('tr:first-child td'))
      .map((td) => td.innerText)
    const values = Array.from(el.nextElementSibling.querySelectorAll('tr:not(:first-child) td'))
      .map((td, idx) => [keys[idx % keys.length].toLowerCase(), td.innerText])
      .reduce((acc, cur, idx) => {
        acc[parseInt(idx / keys.length)] = acc[parseInt(idx / keys.length)] || {}
        acc[parseInt(idx / keys.length)] = Object.assign(acc[parseInt(idx / keys.length)], { [cur[0]]: cur[1] })
        return acc
      }, [])
    console.log(values)
  }

  el = el.nextElementSibling
}

// console.log(code.join('\n'))

Version 3. Sova, please finish this shit...
el = document.getElementById('telegram-passport').parentElement
code = []
cls = ''

while (el.nextElementSibling && el.nextElementSibling.tagName !== 'H3') {
  if (el.nextElementSibling.tagName === 'H4') {
    cls = cls + `class ${el.nextElementSibling.innerText}`
  }

  if (el.nextElementSibling.tagName === 'P') {
    cls = `/**${el.nextElementSibling.innerText.replace(/(.{1,72}\s)\s*?/g, '\n * $1')}
 */\n` + cls
  }

  if (el.nextElementSibling.tagName === 'TABLE') {
    const keys = Array.from(el.nextElementSibling.querySelectorAll('tr:first-child td'))
      .map((td) => td.innerText)
    const values = Array.from(el.nextElementSibling.querySelectorAll('tr:not(:first-child) td'))
      .map((td, idx) => [keys[idx % keys.length].toLowerCase(), td.innerText])
      .reduce((acc, cur, idx) => {
        acc[parseInt(idx / keys.length)] = acc[parseInt(idx / keys.length)] || {}
        acc[parseInt(idx / keys.length)][cur[0]] = cur[1]
        return acc
      }, [])
    cls += '\n{\n\n' + values.map((prop) => `  /**${prop.description.replace(/(.{1,72}\s)\s*?/g, '\n   * $1')}
   */\n  ${prop.parameters || prop.field}\n`).join('\n')
    code.push(`${cls}`)
    cls = ''
  }

  el = el.nextElementSibling
}

console.log(code.join('\n'))

Could you imagine this?
document.querySelectorAll('h3').forEach((el) => {

  const code = []
  let cls = ''
  let comment = []

  while (el.nextElementSibling) {
    if (el.nextElementSibling.tagName === 'H4') {
      cls = `${cls}export type ${el.nextElementSibling.innerText}`
    }

    if (el.nextElementSibling.tagName === 'P') {
      comment = comment + `/**${el.nextElementSibling.innerText.replace(/(.{1,72}\s)\s*?/g, '\n * $1')}\n */\n`
      comment = comment.replace(/\n \*\/\n\/\*\*/g, '\n *')
    }

    if (el.nextElementSibling.tagName === 'TABLE') {
      const keys = Array.from(el.nextElementSibling.querySelectorAll('tr:first-child td'))
        .map((td) => td.innerText)
      const values = Array.from(el.nextElementSibling.querySelectorAll('tr:not(:first-child) td'))
        .map((td, idx) => [keys[idx % keys.length].toLowerCase(), td.innerText])
        .reduce((acc, cur, idx) => {
          acc[parseInt(idx / keys.length)] = acc[parseInt(idx / keys.length)] || {}
          acc[parseInt(idx / keys.length)][cur[0]] = cur[1]
          return acc
        }, [])

      cls += '\n{\n\n' + values.map((prop) => `  /**${prop.description.replace(/“|”/g, '`').replace(/(.{1,72}\s)\s*?/g, '\n   * $1')}\n   */\n  ${prop.parameters || prop.field}: ${prop.type.replace(/Array of (\w+)/, '$1[]')};\n`).join('\n')

      code.push(`${comment}${cls}\n}\n`)
      cls = ''
      comment = ''
    }

    el = el.nextElementSibling
  }

  console.log(code.join('\n'))
})

It is parsing all shit almost correct.
/**
 * Bot API 4.0.
 *
 * Bot API 3.6.
 *
 * See earlier changes »
 *
 * Each bot is given a unique authentication token when it is created. The
 * token looks something like 123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11,
 * but we'll use simply <token> in this document instead. You can learn
 * about obtaining tokens and generating new ones in this document.
 *
 * All queries to the Telegram Bot API must be served over HTTPS and need
 * to be presented in this form:
 * https://api.telegram.org/bot<token>/METHOD_NAME. Like this for example:
 *
 * We support GET and POST HTTP methods. We support four ways of passing
 * parameters in Bot API requests:
 *
 * The response contains a JSON object, which always has a Boolean field
 * ‘ok’ and may have an optional String field ‘description’ with a
 * human-readable description of the result. If ‘ok’ equals true, the
 * request was successful and the result of the query can be found in the
 * ‘result’ field. In case of an unsuccessful request, ‘ok’ equals false
 * and the error is explained in the ‘description’. An Integer ‘error_code’
 * field is also returned, but its contents are subject to change in the
 * future. Some errors may also have an optional field ‘parameters’ of the
 * type ResponseParameters, which can help to automatically handle the error.
 *
 * If you're using webhooks, you can perform a request to the Bot API while
 * sending an answer to the webhook. Use either application/json or
 * application/x-www-form-urlencoded or multipart/form-data response
 * content type for passing parameters. Specify the method to be invoked in
 * the method parameter of the request. It's not possible to know that such
 * a request was successful or get its result.
 *
 * There are two mutually exclusive ways of receiving updates for your bot
 * — the getUpdates method on one hand and Webhooks on the other. Incoming
 * updates are stored on the server until the bot receives them either way,
 * but they will not be kept longer than 24 hours.
 *
 * Regardless of which option you choose, you will receive JSON-serialized
 * Update objects as a result.
 *
 * This object represents an incoming update.

 * At most one of the optional parameters can be present in any given update.
 */
export type July 26, 2018export type February 13, 2018export type Making requests when getting updatesexport type Update
{

  /**
   * The update‘s unique identifier. Update identifiers start from a certain
   * positive number and increase sequentially. This ID becomes especially
   * handy if you’re using Webhooks, since it allows you to ignore repeated
   * updates or to restore the correct update sequence, should they get out
   * of order. If there are no new updates for at least a week, then
   * identifier of the next update will be chosen randomly instead of sequentially.
   */
  update_id: Integer;

  /**
   * Optional. New incoming message of any kind — text, photo, sticker, etc.
   */
  message: Message;

  /**
   * Optional. New version of a message that is known to the bot and was edited
   */
  edited_message: Message;

  /**
   * Optional. New incoming channel post of any kind — text, photo, sticker, etc.
   */
  channel_post: Message;

  /**
   * Optional. New version of a channel post that is known to the bot and was edited
   */
  edited_channel_post: Message;

  /**
   * Optional. New incoming inline query
   */
  inline_query: InlineQuery;

  /**
   * Optional. The result of an inline query that was chosen by a user and
   * sent to their chat partner. Please see our documentation on the feedback
   * collecting for details on how to enable these updates for your bot.
   */
  chosen_inline_result: ChosenInlineResult;

  /**
   * Optional. New incoming callback query
   */
  callback_query: CallbackQuery;

  /**
   * Optional. New incoming shipping query. Only for invoices with flexible price
   */
  shipping_query: ShippingQuery;

  /**
   * Optional. New incoming pre-checkout query. Contains full information
   * about checkout
   */
  pre_checkout_query: PreCheckoutQuery;

}

/**
 * Use this method to receive incoming updates using long polling (wiki).
 * An Array of Update objects is returned.
 */
export type getUpdates
{

  /**
   * Identifier of the first update to be returned. Must be greater by one
   * than the highest among the identifiers of previously received updates.
   * By default, updates starting with the earliest unconfirmed update are
   * returned. An update is considered confirmed as soon as getUpdates is
   * called with an offset higher than its update_id. The negative offset can
   * be specified to retrieve updates starting from -offset update from the
   * end of the updates queue. All previous updates will forgotten.
   */
  offset: Integer;

  /**
   * Limits the number of updates to be retrieved. Values between 1—100 are
   * accepted. Defaults to 100.
   */
  limit: Integer;

  /**
   * Timeout in seconds for lo
VM258:38 /**
 * Each bot is given a unique authentication token when it is created. The
 * token looks something like 123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11,
 * but we'll use simply <token> in this document instead. You can learn
 * about obtaining tokens and generating new ones in this document.
 *
 * All queries to the Telegram Bot API must be served over HTTPS and need
 * to be presented in this form:
 * https://api.telegram.org/bot<token>/METHOD_NAME. Like this for example:
 *
 * We support GET and POST HTTP methods. We support four ways of passing
 * parameters in Bot API requests:
 *
 * The response contains a JSON object, which always has a Boolean field
 * ‘ok’ and may have an optional String field ‘description’ with a
 * human-readable description of the result. If ‘ok’ equals true, the
 * request was successful and the result of the query can be found in the
 * ‘result’ field. In case of an unsuccessful request, ‘ok’ equals false
 * and the error is explained in the ‘description’. An Integer ‘error_code’
 * field is also returned, but its contents are subject to change in the
 * future. Some errors may also have an optional field ‘parameters’ of the
 * type ResponseParameters, which can help to automatically handle the error.
 *
 * If you're using webhooks, you can perform a request to the Bot API while
 * sending an answer to the webhook. Use either application/json or
 * application/x-www-form-urlencoded or multipart/form-data response
 * content type for passing parameters. Specify the method to be invoked in
 * the method parameter of the request. It's not possible to know that such
 * a request was successful or get its result.
 *
 * There are two mutually exclusive ways of receiving updates for your bot
 * — the getUpdates method on one hand and Webhooks on the other. Incoming
 * updates are stored on the server until the bot receives them either way,
 * but they will not be kept longer than 24 hours.
 *
 * Regardless of which option you choose, you will receive JSON-serialized
 * Update objects as a result.
 *
 * This object represents an incoming update.

 * At most one of the optional parameters can be present in any given update.
 */
export type Making requests when getting updatesexport type Update
{

  /**
   * The update‘s unique identifier. Update identifiers start from a certain
   * positive number and increase sequentially. This ID becomes especially
   * handy if you’re using Webhooks, since it allows you to ignore repeated
   * updates or to restore the correct update sequence, should they get out
   * of order. If there are no new updates for at least a week, then
   * identifier of the next update will be chosen randomly instead of sequentially.
   */
  update_id: Integer;

  /**
   * Optional. New incoming message of any kind — text, photo, sticker, etc.
   */
  message: Message;

  /**
   * Optional. New version of a message that is known to the bot and was edited
   */
  edited_message: Message;

  /**
   * Optional. New incoming channel post of any kind — text, photo, sticker, etc.
   */
  channel_post: Message;

  /**
   * Optional. New version of a channel post that is known to the bot and was edited
   */
  edited_channel_post: Message;

  /**
   * Optional. New incoming inline query
   */
  inline_query: InlineQuery;

  /**
   * Optional. The result of an inline query that was chosen by a user and
   * sent to their chat partner. Please see our documentation on the feedback
   * collecting for details on how to enable these updates for your bot.
   */
  chosen_inline_result: ChosenInlineResult;

  /**
   * Optional. New incoming callback query
   */
  callback_query: CallbackQuery;

  /**
   * Optional. New incoming shipping query. Only for invoices with flexible price
   */
  shipping_query: ShippingQuery;

  /**
   * Optional. New incoming pre-checkout query. Contains full information
   * about checkout
   */
  pre_checkout_query: PreCheckoutQuery;

}

/**
 * Use this method to receive incoming updates using long polling (wiki).
 * An Array of Update objects is returned.
 */
export type getUpdates
{

  /**
   * Identifier of the first update to be returned. Must be greater by one
   * than the highest among the identifiers of previously received updates.
   * By default, updates starting with the earliest unconfirmed update are
   * returned. An update is considered confirmed as soon as getUpdates is
   * called with an offset higher than its update_id. The negative offset can
   * be specified to retrieve updates starting from -offset update from the
   * end of the updates queue. All previous updates will forgotten.
   */
  offset: Integer;

  /**
   * Limits the number of updates to be retrieved. Values between 1—100 are
   * accepted. Defaults to 100.
   */
  limit: Integer;

  /**
   * Timeout in seconds for long polling. Defaults to 0, i.e. usual short
   * polling. Should be positive, short polling should be used for testing
VM258:38 /**
 * All queries to the Telegram Bot API must be served over HTTPS and need
 * to be presented in this form:
 * https://api.telegram.org/bot<token>/METHOD_NAME. Like this for example:
 *
 * We support GET and POST HTTP methods. We support four ways of passing
 * parameters in Bot API requests:
 *
 * The response contains a JSON object, which always has a Boolean field
 * ‘ok’ and may have an optional String field ‘description’ with a
 * human-readable description of the result. If ‘ok’ equals true, the
 * request was successful and the result of the query can be found in the
 * ‘result’ field. In case of an unsuccessful request, ‘ok’ equals false
 * and the error is explained in the ‘description’. An Integer ‘error_code’
 * field is also returned, but its contents are subject to change in the
 * future. Some errors may also have an optional field ‘parameters’ of the
 * type ResponseParameters, which can help to automatically handle the error.
 *
 * If you're using webhooks, you can perform a request to the Bot API while
 * sending an answer to the webhook. Use either application/json or
 * application/x-www-form-urlencoded or multipart/form-data response
 * content type for passing parameters. Specify the method to be invoked in
 * the method parameter of the request. It's not possible to know that such
 * a request was successful or get its result.
 *
 * There are two mutually exclusive ways of receiving updates for your bot
 * — the getUpdates method on one hand and Webhooks on the other. Incoming
 * updates are stored on the server until the bot receives them either way,
 * but they will not be kept longer than 24 hours.
 *
 * Regardless of which option you choose, you will receive JSON-serialized
 * Update objects as a result.
 *
 * This object represents an incoming update.

 * At most one of the optional parameters can be present in any given update.
 */
export type Making requests when getting updatesexport type Update
{

  /**
   * The update‘s unique identifier. Update identifiers start from a certain
   * positive number and increase sequentially. This ID becomes especially
   * handy if you’re using Webhooks, since it allows you to ignore repeated
   * updates or to restore the correct update sequence, should they get out
   * of order. If there are no new updates for at least a week, then
   * identifier of the next update will be chosen randomly instead of sequentially.
   */
  update_id: Integer;

  /**
   * Optional. New incoming message of any kind — text, photo, sticker, etc.
   */
  message: Message;

  /**
   * Optional. New version of a message that is known to the bot and was edited
   */
  edited_message: Message;

  /**
   * Optional. New incoming channel post of any kind — text, photo, sticker, etc.
   */
  channel_post: Message;

  /**
   * Optional. New version of a channel post that is known to the bot and was edited
   */
  edited_channel_post: Message;

  /**
   * Optional. New incoming inline query
   */
  inline_query: InlineQuery;

  /**
   * Optional. The result of an inline query that was chosen by a user and
   * sent to their chat partner. Please see our documentation on the feedback
   * collecting for details on how to enable these updates for your bot.
   */
  chosen_inline_result: ChosenInlineResult;

  /**
   * Optional. New incoming callback query
   */
  callback_query: CallbackQuery;

  /**
   * Optional. New incoming shipping query. Only for invoices with flexible price
   */
  shipping_query: ShippingQuery;

  /**
   * Optional. New incoming pre-checkout query. Contains full information
   * about checkout
   */
  pre_checkout_query: PreCheckoutQuery;

}

/**
 * Use this method to receive incoming updates using long polling (wiki).
 * An Array of Update objects is returned.
 */
export type getUpdates
{

  /**
   * Identifier of the first update to be returned. Must be greater by one
   * than the highest among the identifiers of previously received updates.
   * By default, updates starting with the earliest unconfirmed update are
   * returned. An update is considered confirmed as soon as getUpdates is
   * called with an offset higher than its update_id. The negative offset can
   * be specified to retrieve updates starting from -offset update from the
   * end of the updates queue. All previous updates will forgotten.
   */
  offset: Integer;

  /**
   * Limits the number of updates to be retrieved. Values between 1—100 are
   * accepted. Defaults to 100.
   */
  limit: Integer;

  /**
   * Timeout in seconds for long polling. Defaults to 0, i.e. usual short
   * polling. Should be positive, short polling should be used for testing
   * purposes only.
   */
  timeout: Integer;

  /**
   * List the types of updates you want your bot to receive. For example,
   * specify [`message`, `edited_channel_post`, `callback_query`] to only
   * receive updates of these types. See Update for a complete list of
   * available upd
VM258:38 /**
 * There are two mutually exclusive ways of receiving updates for your bot
 * — the getUpdates method on one hand and Webhooks on the other. Incoming
 * updates are stored on the server until the bot receives them either way,
 * but they will not be kept longer than 24 hours.
 *
 * Regardless of which option you choose, you will receive JSON-serialized
 * Update objects as a result.
 *
 * This object represents an incoming update.

 * At most one of the optional parameters can be present in any given update.
 */
export type Update
{

  /**
   * The update‘s unique identifier. Update identifiers start from a certain
   * positive number and increase sequentially. This ID becomes especially
   * handy if you’re using Webhooks, since it allows you to ignore repeated
   * updates or to restore the correct update sequence, should they get out
   * of order. If there are no new updates for at least a week, then
   * identifier of the next update will be chosen randomly instead of sequentially.
   */
  update_id: Integer;

  /**
   * Optional. New incoming message of any kind — text, photo, sticker, etc.
   */
  message: Message;

  /**
   * Optional. New version of a message that is known to the bot and was edited
   */
  edited_message: Message;

  /**
   * Optional. New incoming channel post of any kind — text, photo, sticker, etc.
   */
  channel_post: Message;

  /**
   * Optional. New version of a channel post that is known to the bot and was edited
   */
  edited_channel_post: Message;

  /**
   * Optional. New incoming inline query
   */
  inline_query: InlineQuery;

  /**
   * Optional. The result of an inline query that was chosen by a user and
   * sent to their chat partner. Please see our documentation on the feedback
   * collecting for details on how to enable these updates for your bot.
   */
  chosen_inline_result: ChosenInlineResult;

  /**
   * Optional. New incoming callback query
   */
  callback_query: CallbackQuery;

  /**
   * Optional. New incoming shipping query. Only for invoices with flexible price
   */
  shipping_query: ShippingQuery;

  /**
   * Optional. New incoming pre-checkout query. Contains full information
   * about checkout
   */
  pre_checkout_query: PreCheckoutQuery;

}

/**
 * Use this method to receive incoming updates using long polling (wiki).
 * An Array of Update objects is returned.
 */
export type getUpdates
{

  /**
   * Identifier of the first update to be returned. Must be greater by one
   * than the highest among the identifiers of previously received updates.
   * By default, updates starting with the earliest unconfirmed update are
   * returned. An update is considered confirmed as soon as getUpdates is
   * called with an offset higher than its update_id. The negative offset can
   * be specified to retrieve updates starting from -offset update from the
   * end of the updates queue. All previous updates will forgotten.
   */
  offset: Integer;

  /**
   * Limits the number of updates to be retrieved. Values between 1—100 are
   * accepted. Defaults to 100.
   */
  limit: Integer;

  /**
   * Timeout in seconds for long polling. Defaults to 0, i.e. usual short
   * polling. Should be positive, short polling should be used for testing
   * purposes only.
   */
  timeout: Integer;

  /**
   * List the types of updates you want your bot to receive. For example,
   * specify [`message`, `edited_channel_post`, `callback_query`] to only
   * receive updates of these types. See Update for a complete list of
   * available update types. Specify an empty list to receive all updates
   * regardless of type (default). If not specified, the previous setting
   * will be used.

   * Please note that this parameter doesn't affect updates created before
   * the call to the getUpdates, so unwanted updates may be received for a
   * short period of time.
   */
  allowed_updates: String[];

}

/**
 * Use this method to specify a url and receive incoming updates via an
 * outgoing webhook. Whenever there is an update for the bot, we will send
 * an HTTPS POST request to the specified url, containing a JSON-serialized
 * Update. In case of an unsuccessful request, we will give up after a
 * reasonable amount of attempts. Returns True on success.
 *
 * If you'd like to make sure that the Webhook request comes from Telegram,
 * we recommend using a secret path in the URL, e.g.
 * https://www.example.com/<token>. Since nobody else knows your bot‘s
 * token, you can be pretty sure it’s us.
 */
export type setWebhook
{

  /**
   * HTTPS url to send updates to. Use an empty string to remove webhook integration
   */
  url: String;

  /**
   * Upload your public key certificate so that the root certificate in use
   * can be checked. See our self-signed guide for details.
   */
  certificate: InputFile;

  /**
   * Maximum allowed number of simultaneous HTTPS connections to the webhook
   * for update delivery, 1-100. Defaults to 40. Use l
VM258:38 /**
 * All types used in the Bot API responses are represented as JSON-objects.
 *
 * It is safe to use 32-bit signed integers for storing all Integer fields
 * unless otherwise noted.
 *
 * This object represents a Telegram user or bot.
 */
export type User
{

  /**
   * Unique identifier for this user or bot
   */
  id: Integer;

  /**
   * True, if this user is a bot
   */
  is_bot: Boolean;

  /**
   * User‘s or bot’s first name
   */
  first_name: String;

  /**
   * Optional. User‘s or bot’s last name
   */
  last_name: String;

  /**
   * Optional. User‘s or bot’s username
   */
  username: String;

  /**
   * Optional. IETF language tag of the user's language
   */
  language_code: String;

}

/**
 * This object represents a chat.
 */
export type Chat
{

  /**
   * Unique identifier for this chat. This number may be greater than 32 bits
   * and some programming languages may have difficulty/silent defects in
   * interpreting it. But it is smaller than 52 bits, so a signed 64 bit
   * integer or double-precision float type are safe for storing this identifier.
   */
  id: Integer;

  /**
   * Type of chat, can be either `private`, `group`, `supergroup` or `channel`
   */
  type: String;

  /**
   * Optional. Title, for supergroups, channels and group chats
   */
  title: String;

  /**
   * Optional. Username, for private chats, supergroups and channels if available
   */
  username: String;

  /**
   * Optional. First name of the other party in a private chat
   */
  first_name: String;

  /**
   * Optional. Last name of the other party in a private chat
   */
  last_name: String;

  /**
   * Optional. True if a group has ‘All Members Are Admins’ enabled.
   */
  all_members_are_administrators: Boolean;

  /**
   * Optional. Chat photo. Returned only in getChat.
   */
  photo: ChatPhoto;

  /**
   * Optional. Description, for supergroups and channel chats. Returned only
   * in getChat.
   */
  description: String;

  /**
   * Optional. Chat invite link, for supergroups and channel chats. Returned
   * only in getChat.
   */
  invite_link: String;

  /**
   * Optional. Pinned message, for supergroups and channel chats. Returned
   * only in getChat.
   */
  pinned_message: Message;

  /**
   * Optional. For supergroups, name of group sticker set. Returned only in getChat.
   */
  sticker_set_name: String;

  /**
   * Optional. True, if the bot can change the group sticker set. Returned
   * only in getChat.
   */
  can_set_sticker_set: Boolean;

}

/**
 * This object represents a message.
 */
export type Message
{

  /**
   * Unique message identifier inside this chat
   */
  message_id: Integer;

  /**
   * Optional. Sender, empty for messages sent to channels
   */
  from: User;

  /**
   * Date the message was sent in Unix time
   */
  date: Integer;

  /**
   * Conversation the message belongs to
   */
  chat: Chat;

  /**
   * Optional. For forwarded messages, sender of the original message
   */
  forward_from: User;

  /**
   * Optional. For messages forwarded from channels, information about the
   * original channel
   */
  forward_from_chat: Chat;

  /**
   * Optional. For messages forwarded from channels, identifier of the
   * original message in the channel
   */
  forward_from_message_id: Integer;

  /**
   * Optional. For messages forwarded from channels, signature of the post
   * author if present
   */
  forward_signature: String;

  /**
   * Optional. For forwarded messages, date the original message was sent in
   * Unix time
   */
  forward_date: Integer;

  /**
   * Optional. For replies, the original message. Note that the Message
   * object in this field will not contain further reply_to_message fields
   * even if it itself is a reply.
   */
  reply_to_message: Message;

  /**
   * Optional. Date the message was last edited in Unix time
   */
  edit_date: Integer;

  /**
   * Optional. The unique identifier of a media message group this message
   * belongs to
   */
  media_group_id: String;

  /**
   * Optional. Signature of the post author for messages in channels
   */
  author_signature: String;

  /**
   * Optional. For text messages, the actual UTF-8 text of the message,
   * 0-4096 characters.
   */
  text: String;

  /**
   * Optional. For text messages, special entities like usernames, URLs, bot
   * commands, etc. that appear in the text
   */
  entities: MessageEntity[];

  /**
   * Optional. For messages with a caption, special entities like usernames,
   * URLs, bot commands, etc. that appear in the caption
   */
  caption_entities: MessageEntity[];

  /**
   * Optional. Message is an audio file, information about the file
   */
  audio: Audio;

  /**
   * Optional. Message is a general file, information about the file
   */
  document: Document;

  /**
   * Optional. Message is an animation, information about the animation. For
   * backward compatibility, when this field is set, the document field will
   * also be set
   */
  animation:
VM258:38 /**
 * A simple method for testing your bot's auth token. Requires no
 * parameters. Returns basic information about the bot in form of a User object.
 *
 * Use this method to send text messages. On success, the sent Message is returned.
 */
export type getMeexport type sendMessage
{

  /**
   * Unique identifier for the target chat or username of the target channel
   * (in the format @channelusername)
   */
  chat_id: Integer or String;

  /**
   * Text of the message to be sent
   */
  text: String;

  /**
   * Send Markdown or HTML, if you want Telegram apps to show bold, italic,
   * fixed-width text or inline URLs in your bot's message.
   */
  parse_mode: String;

  /**
   * Disables link previews for links in this message
   */
  disable_web_page_preview: Boolean;

  /**
   * Sends the message silently. Users will receive a notification with no sound.
   */
  disable_notification: Boolean;

  /**
   * If the message is a reply, ID of the original message
   */
  reply_to_message_id: Integer;

  /**
   * Additional interface options. A JSON-serialized object for an inline
   * keyboard, custom reply keyboard, instructions to remove reply keyboard
   * or to force a reply from the user.
   */
  reply_markup: InlineKeyboardMarkup or ReplyKeyboardMarkup or ReplyKeyboardRemove or ForceReply;

}

/**
 * The Bot API supports basic formatting for messages. You can use bold and
 * italic text, as well as inline links and pre-formatted code in your
 * bots' messages. Telegram clients will render them accordingly. You can
 * use either markdown-style or HTML-style formatting.
 *
 * Note that Telegram clients will display an alert to the user before
 * opening an inline link (‘Open this link?’ together with the full URL).
 *
 * Links tg://user?id=<user_id> can be used to mention a user by their id
 * without using a username. Please note:
 *
 * To use this mode, pass Markdown in the parse_mode field when using
 * sendMessage. Use the following syntax in your message:
 *
 * To use this mode, pass HTML in the parse_mode field when using
 * sendMessage. The following tags are currently supported:
 *
 * Please note:
 *
 * Use this method to forward messages of any kind. On success, the sent
 * Message is returned.
 */
export type Formatting optionsexport type forwardMessage
{

  /**
   * Unique identifier for the target chat or username of the target channel
   * (in the format @channelusername)
   */
  chat_id: Integer or String;

  /**
   * Unique identifier for the chat where the original message was sent (or
   * channel username in the format @channelusername)
   */
  from_chat_id: Integer or String;

  /**
   * Sends the message silently. Users will receive a notification with no sound.
   */
  disable_notification: Boolean;

  /**
   * Message identifier in the chat specified in from_chat_id
   */
  message_id: Integer;

}

/**
 * Use this method to send photos. On success, the sent Message is returned.
 */
export type sendPhoto
{

  /**
   * Unique identifier for the target chat or username of the target channel
   * (in the format @channelusername)
   */
  chat_id: Integer or String;

  /**
   * Photo to send. Pass a file_id as String to send a photo that exists on
   * the Telegram servers (recommended), pass an HTTP URL as a String for
   * Telegram to get a photo from the Internet, or upload a new photo using
   * multipart/form-data. More info on Sending Files »
   */
  photo: InputFile or String;

  /**
   * Photo caption (may also be used when resending photos by file_id), 0-200 characters
   */
  caption: String;

  /**
   * Send Markdown or HTML, if you want Telegram apps to show bold, italic,
   * fixed-width text or inline URLs in the media caption.
   */
  parse_mode: String;

  /**
   * Sends the message silently. Users will receive a notification with no sound.
   */
  disable_notification: Boolean;

  /**
   * If the message is a reply, ID of the original message
   */
  reply_to_message_id: Integer;

  /**
   * Additional interface options. A JSON-serialized object for an inline
   * keyboard, custom reply keyboard, instructions to remove reply keyboard
   * or to force a reply from the user.
   */
  reply_markup: InlineKeyboardMarkup or ReplyKeyboardMarkup or ReplyKeyboardRemove or ForceReply;

}

/**
 * Use this method to send audio files, if you want Telegram clients to
 * display them in the music player. Your audio must be in the .mp3 format.
 * On success, the sent Message is returned. Bots can currently send audio
 * files of up to 50 MB in size, this limit may be changed in the future.
 *
 * For sending voice messages, use the sendVoice method instead.
 */
export type sendAudio
{

  /**
   * Unique identifier for the target chat or username of the target channel
   * (in the format @channelusername)
   */
  chat_id: Integer or String;

  /**
   * Audio file to send. Pass a file_id as String to send an audio file that
   * exists on the Telegram servers (rec
VM258:38 /**
 * The following methods allow you to change an existing message in the
 * message history instead of sending a new one with a result of an action.
 * This is most useful for messages with inline keyboards using callback
 * queries, but can also help reduce clutter in conversations with regular
 * chat bots.
 *
 * Please note, that it is currently only possible to edit messages without
 * reply_markup or with inline keyboards.
 *
 * Use this method to edit text and game messages sent by the bot or via
 * the bot (for inline bots). On success, if edited message is sent by the
 * bot, the edited Message is returned, otherwise True is returned.
 */
export type editMessageText
{

  /**
   * Required if inline_message_id is not specified. Unique identifier for
   * the target chat or username of the target channel (in the format @channelusername)
   */
  chat_id: Integer or String;

  /**
   * Required if inline_message_id is not specified. Identifier of the sent message
   */
  message_id: Integer;

  /**
   * Required if chat_id and message_id are not specified. Identifier of the
   * inline message
   */
  inline_message_id: String;

  /**
   * New text of the message
   */
  text: String;

  /**
   * Send Markdown or HTML, if you want Telegram apps to show bold, italic,
   * fixed-width text or inline URLs in your bot's message.
   */
  parse_mode: String;

  /**
   * Disables link previews for links in this message
   */
  disable_web_page_preview: Boolean;

  /**
   * A JSON-serialized object for an inline keyboard.
   */
  reply_markup: InlineKeyboardMarkup;

}

/**
 * Use this method to edit captions of messages sent by the bot or via the
 * bot (for inline bots). On success, if edited message is sent by the bot,
 * the edited Message is returned, otherwise True is returned.
 */
export type editMessageCaption
{

  /**
   * Required if inline_message_id is not specified. Unique identifier for
   * the target chat or username of the target channel (in the format @channelusername)
   */
  chat_id: Integer or String;

  /**
   * Required if inline_message_id is not specified. Identifier of the sent message
   */
  message_id: Integer;

  /**
   * Required if chat_id and message_id are not specified. Identifier of the
   * inline message
   */
  inline_message_id: String;

  /**
   * New caption of the message
   */
  caption: String;

  /**
   * Send Markdown or HTML, if you want Telegram apps to show bold, italic,
   * fixed-width text or inline URLs in the media caption.
   */
  parse_mode: String;

  /**
   * A JSON-serialized object for an inline keyboard.
   */
  reply_markup: InlineKeyboardMarkup;

}

/**
 * Use this method to edit audio, document, photo, or video messages. If a
 * message is a part of a message album, then it can be edited only to a
 * photo or a video. Otherwise, message type can be changed arbitrarily.
 * When inline message is edited, new file can't be uploaded. Use
 * previously uploaded file via its file_id or specify a URL. On success,
 * if the edited message was sent by the bot, the edited Message is
 * returned, otherwise True is returned.
 */
export type editMessageMedia
{

  /**
   * Required if inline_message_id is not specified. Unique identifier for
   * the target chat or username of the target channel (in the format @channelusername)
   */
  chat_id: Integer or String;

  /**
   * Required if inline_message_id is not specified. Identifier of the sent message
   */
  message_id: Integer;

  /**
   * Required if chat_id and message_id are not specified. Identifier of the
   * inline message
   */
  inline_message_id: String;

  /**
   * A JSON-serialized object for a new media content of the message
   */
  media: InputMedia;

  /**
   * A JSON-serialized object for a new inline keyboard.
   */
  reply_markup: InlineKeyboardMarkup;

}

/**
 * Use this method to edit only the reply markup of messages sent by the
 * bot or via the bot (for inline bots). On success, if edited message is
 * sent by the bot, the edited Message is returned, otherwise True is returned.
 */
export type editMessageReplyMarkup
{

  /**
   * Required if inline_message_id is not specified. Unique identifier for
   * the target chat or username of the target channel (in the format @channelusername)
   */
  chat_id: Integer or String;

  /**
   * Required if inline_message_id is not specified. Identifier of the sent message
   */
  message_id: Integer;

  /**
   * Required if chat_id and message_id are not specified. Identifier of the
   * inline message
   */
  inline_message_id: String;

  /**
   * A JSON-serialized object for an inline keyboard.
   */
  reply_markup: InlineKeyboardMarkup;

}

/**
 * Use this method to delete a message, including service messages, with
 * the following limitations:

 * - A message can only be deleted if it was sent less than 48 hours ago.

 * - Bots can delete outgoing messages in groups and supergroups.

 * - Bots granted can_post_me
VM258:38 /**
 * The following methods and objects allow your bot to handle stickers and
 * sticker sets.
 *
 * This object represents a sticker.
 */
export type Sticker
{

  /**
   * Unique identifier for this file
   */
  file_id: String;

  /**
   * Sticker width
   */
  width: Integer;

  /**
   * Sticker height
   */
  height: Integer;

  /**
   * Optional. Sticker thumbnail in the .webp or .jpg format
   */
  thumb: PhotoSize;

  /**
   * Optional. Emoji associated with the sticker
   */
  emoji: String;

  /**
   * Optional. Name of the sticker set to which the sticker belongs
   */
  set_name: String;

  /**
   * Optional. For mask stickers, the position where the mask should be placed
   */
  mask_position: MaskPosition;

  /**
   * Optional. File size
   */
  file_size: Integer;

}

/**
 * This object represents a sticker set.
 */
export type StickerSet
{

  /**
   * Sticker set name
   */
  name: String;

  /**
   * Sticker set title
   */
  title: String;

  /**
   * True, if the sticker set contains masks
   */
  contains_masks: Boolean;

  /**
   * List of all set stickers
   */
  stickers: Sticker[];

}

/**
 * This object describes the position on faces where a mask should be
 * placed by default.
 */
export type MaskPosition
{

  /**
   * The part of the face relative to which the mask should be placed. One of
   * `forehead`, `eyes`, `mouth`, or `chin`.
   */
  point: String;

  /**
   * Shift by X-axis measured in widths of the mask scaled to the face size,
   * from left to right. For example, choosing -1.0 will place mask just to
   * the left of the default mask position.
   */
  x_shift: Float number;

  /**
   * Shift by Y-axis measured in heights of the mask scaled to the face size,
   * from top to bottom. For example, 1.0 will place the mask just below the
   * default mask position.
   */
  y_shift: Float number;

  /**
   * Mask scaling coefficient. For example, 2.0 means double size.
   */
  scale: Float number;

}

/**
 * Use this method to send .webp stickers. On success, the sent Message is returned.
 */
export type sendSticker
{

  /**
   * Unique identifier for the target chat or username of the target channel
   * (in the format @channelusername)
   */
  chat_id: Integer or String;

  /**
   * Sticker to send. Pass a file_id as String to send a file that exists on
   * the Telegram servers (recommended), pass an HTTP URL as a String for
   * Telegram to get a .webp file from the Internet, or upload a new one
   * using multipart/form-data. More info on Sending Files »
   */
  sticker: InputFile or String;

  /**
   * Sends the message silently. Users will receive a notification with no sound.
   */
  disable_notification: Boolean;

  /**
   * If the message is a reply, ID of the original message
   */
  reply_to_message_id: Integer;

  /**
   * Additional interface options. A JSON-serialized object for an inline
   * keyboard, custom reply keyboard, instructions to remove reply keyboard
   * or to force a reply from the user.
   */
  reply_markup: InlineKeyboardMarkup or ReplyKeyboardMarkup or ReplyKeyboardRemove or ForceReply;

}

/**
 * Use this method to get a sticker set. On success, a StickerSet object is returned.
 */
export type getStickerSet
{

  /**
   * Name of the sticker set
   */
  name: String;

}

/**
 * Use this method to upload a .png file with a sticker for later use in
 * createNewStickerSet and addStickerToSet methods (can be used multiple
 * times). Returns the uploaded File on success.
 */
export type uploadStickerFile
{

  /**
   * User identifier of sticker file owner
   */
  user_id: Integer;

  /**
   * Png image with the sticker, must be up to 512 kilobytes in size,
   * dimensions must not exceed 512px, and either width or height must be
   * exactly 512px. More info on Sending Files »
   */
  png_sticker: InputFile;

}

/**
 * Use this method to create new sticker set owned by a user. The bot will
 * be able to edit the created sticker set. Returns True on success.
 */
export type createNewStickerSet
{

  /**
   * User identifier of created sticker set owner
   */
  user_id: Integer;

  /**
   * Short name of sticker set, to be used in t.me/addstickers/ URLs (e.g.,
   * animals). Can contain only english letters, digits and underscores. Must
   * begin with a letter, can't contain consecutive underscores and must end
   * in `_by_<bot username>`. <bot_username> is case insensitive. 1-64 characters.
   */
  name: String;

  /**
   * Sticker set title, 1-64 characters
   */
  title: String;

  /**
   * Png image with the sticker, must be up to 512 kilobytes in size,
   * dimensions must not exceed 512px, and either width or height must be
   * exactly 512px. Pass a file_id as a String to send a file that already
   * exists on the Telegram servers, pass an HTTP URL as a String for
   * Telegram to get a file from the Internet, or upload a new one using
   * multipart/form-data. More info on Sending Files »
   */
  png_sticker: In
VM258:38 /**
 * The following methods and objects allow your bot to work in inline mode.

 * Please see our Introduction to Inline bots for more details.
 *
 * To enable this option, send the /setinline command to @BotFather and
 * provide the placeholder text that the user will see in the input field
 * after typing your bot’s name.
 *
 * This object represents an incoming inline query. When the user sends an
 * empty query, your bot could return some default or trending results.
 */
export type InlineQuery
{

  /**
   * Unique identifier for this query
   */
  id: String;

  /**Sender
   */
  from: User;

  /**
   * Optional. Sender location, only for bots that request user location
   */
  location: Location;

  /**
   * Text of the query (up to 512 characters)
   */
  query: String;

  /**
   * Offset of the results to be returned, can be controlled by the bot
   */
  offset: String;

}

/**
 * Use this method to send answers to an inline query. On success, True is
 * returned.

 * No more than 50 results per query are allowed.
 */
export type answerInlineQuery
{

  /**
   * Unique identifier for the answered query
   */
  inline_query_id: String;

  /**
   * A JSON-serialized array of results for the inline query
   */
  results: InlineQueryResult[];

  /**
   * The maximum amount of time in seconds that the result of the inline
   * query may be cached on the server. Defaults to 300.
   */
  cache_time: Integer;

  /**
   * Pass True, if results may be cached on the server side only for the user
   * that sent the query. By default, results may be returned to any user who
   * sends the same query
   */
  is_personal: Boolean;

  /**
   * Pass the offset that a client should send in the next query with the
   * same text to receive more results. Pass an empty string if there are no
   * more results or if you don‘t support pagination. Offset length can’t
   * exceed 64 bytes.
   */
  next_offset: String;

  /**
   * If passed, clients will display a button with specified text that
   * switches the user to a private chat with the bot and sends the bot a
   * start message with the parameter switch_pm_parameter
   */
  switch_pm_text: String;

  /**
   * Deep-linking parameter for the /start message sent to the bot when user
   * presses the switch button. 1-64 characters, only A-Z, a-z, 0-9, _ and -
   * are allowed.

   * Example: An inline bot that sends YouTube videos can ask the user to
   * connect the bot to their YouTube account to adapt search results
   * accordingly. To do this, it displays a ‘Connect your YouTube account’
   * button above the results, or even before showing any. The user presses
   * the button, switches to a private chat with the bot and, in doing so,
   * passes a start parameter that instructs the bot to return an oauth link.
   * Once done, the bot can offer a switch_inline button so that the user can
   * easily return to the chat where they wanted to use the bot's inline capabilities.
   */
  switch_pm_parameter: String;

}

/**
 * This object represents one result of an inline query. Telegram clients
 * currently support results of the following 20 types:
 *
 * Represents a link to an article or web page.
 */
export type InlineQueryResultexport type InlineQueryResultArticle
{

  /**
   * Type of the result, must be article
   */
  type: String;

  /**
   * Unique identifier for this result, 1-64 Bytes
   */
  id: String;

  /**
   * Title of the result
   */
  title: String;

  /**
   * Content of the message to be sent
   */
  input_message_content: InputMessageContent;

  /**
   * Optional. Inline keyboard attached to the message
   */
  reply_markup: InlineKeyboardMarkup;

  /**
   * Optional. URL of the result
   */
  url: String;

  /**
   * Optional. Pass True, if you don't want the URL to be shown in the message
   */
  hide_url: Boolean;

  /**
   * Optional. Short description of the result
   */
  description: String;

  /**
   * Optional. Url of the thumbnail for the result
   */
  thumb_url: String;

  /**
   * Optional. Thumbnail width
   */
  thumb_width: Integer;

  /**
   * Optional. Thumbnail height
   */
  thumb_height: Integer;

}

/**
 * Represents a link to a photo. By default, this photo will be sent by the
 * user with optional caption. Alternatively, you can use
 * input_message_content to send a message with the specified content
 * instead of the photo.
 */
export type InlineQueryResultPhoto
{

  /**
   * Type of the result, must be photo
   */
  type: String;

  /**
   * Unique identifier for this result, 1-64 bytes
   */
  id: String;

  /**
   * A valid URL of the photo. Photo must be in jpeg format. Photo size must
   * not exceed 5MB
   */
  photo_url: String;

  /**
   * URL of the thumbnail for the photo
   */
  thumb_url: String;

  /**
   * Optional. Width of the photo
   */
  photo_width: Integer;

  /**
   * Optional. Height of the photo
   */
  photo_height: Integer;

  /**
   * Optional. Title for the result

VM258:38 /**
 * Your bot can accept payments from Telegram users. Please see the
 * introduction to payments for more details on the process and how to set
 * up payments for your bot. Please note that users will need Telegram
 * v.4.0 or higher to use payments (released on May 18, 2017).
 *
 * Use this method to send invoices. On success, the sent Message is returned.
 */
export type sendInvoice
{

  /**
   * Unique identifier for the target private chat
   */
  chat_id: Integer;

  /**
   * Product name, 1-32 characters
   */
  title: String;

  /**
   * Product description, 1-255 characters
   */
  description: String;

  /**
   * Bot-defined invoice payload, 1-128 bytes. This will not be displayed to
   * the user, use for your internal processes.
   */
  payload: String;

  /**
   * Payments provider token, obtained via Botfather
   */
  provider_token: String;

  /**
   * Unique deep-linking parameter that can be used to generate this invoice
   * when used as a start parameter
   */
  start_parameter: String;

  /**
   * Three-letter ISO 4217 currency code, see more on currencies
   */
  currency: String;

  /**
   * Price breakdown, a list of components (e.g. product price, tax,
   * discount, delivery cost, delivery tax, bonus, etc.)
   */
  prices: LabeledPrice[];

  /**
   * JSON-encoded data about the invoice, which will be shared with the
   * payment provider. A detailed description of required fields should be
   * provided by the payment provider.
   */
  provider_data: String;

  /**
   * URL of the product photo for the invoice. Can be a photo of the goods or
   * a marketing image for a service. People like it better when they see
   * what they are paying for.
   */
  photo_url: String;

  /**
   * Photo size
   */
  photo_size: Integer;

  /**
   * Photo width
   */
  photo_width: Integer;

  /**
   * Photo height
   */
  photo_height: Integer;

  /**
   * Pass True, if you require the user's full name to complete the order
   */
  need_name: Boolean;

  /**
   * Pass True, if you require the user's phone number to complete the order
   */
  need_phone_number: Boolean;

  /**
   * Pass True, if you require the user's email address to complete the order
   */
  need_email: Boolean;

  /**
   * Pass True, if you require the user's shipping address to complete the order
   */
  need_shipping_address: Boolean;

  /**
   * Pass True, if user's phone number should be sent to provider
   */
  send_phone_number_to_provider: Boolean;

  /**
   * Pass True, if user's email address should be sent to provider
   */
  send_email_to_provider: Boolean;

  /**
   * Pass True, if the final price depends on the shipping method
   */
  is_flexible: Boolean;

  /**
   * Sends the message silently. Users will receive a notification with no sound.
   */
  disable_notification: Boolean;

  /**
   * If the message is a reply, ID of the original message
   */
  reply_to_message_id: Integer;

  /**
   * A JSON-serialized object for an inline keyboard. If empty, one 'Pay
   * total price' button will be shown. If not empty, the first button must
   * be a Pay button.
   */
  reply_markup: InlineKeyboardMarkup;

}

/**
 * If you sent an invoice requesting a shipping address and the parameter
 * is_flexible was specified, the Bot API will send an Update with a
 * shipping_query field to the bot. Use this method to reply to shipping
 * queries. On success, True is returned.
 */
export type answerShippingQuery
{

  /**
   * Unique identifier for the query to be answered
   */
  shipping_query_id: String;

  /**
   * Specify True if delivery to the specified address is possible and False
   * if there are any problems (for example, if delivery to the specified
   * address is not possible)
   */
  ok: Boolean;

  /**
   * Required if ok is True. A JSON-serialized array of available shipping options.
   */
  shipping_options: ShippingOption[];

  /**
   * Required if ok is False. Error message in human readable form that
   * explains why it is impossible to complete the order (e.g. "Sorry,
   * delivery to your desired address is unavailable'). Telegram will display
   * this message to the user.
   */
  error_message: String;

}

/**
 * Once the user has confirmed their payment and shipping details, the Bot
 * API sends the final confirmation in the form of an Update with the field
 * pre_checkout_query. Use this method to respond to such pre-checkout
 * queries. On success, True is returned. Note: The Bot API must receive an
 * answer within 10 seconds after the pre-checkout query was sent.
 */
export type answerPreCheckoutQuery
{

  /**
   * Unique identifier for the query to be answered
   */
  pre_checkout_query_id: String;

  /**
   * Specify True if everything is alright (goods are available, etc.) and
   * the bot is ready to proceed with the order. Use False if there are any problems.
   */
  ok: Boolean;

  /**
   * Required if ok is False. Error message in human readable form that
   * expl
VM258:38 /**
 * Telegram Passport is a unified authorization method for services that
 * require personal identification. Users can upload their documents once,
 * then instantly share their data with services that require real-world ID
 * (finance, ICOs, etc.). Please see the manual for details.
 *
 * Contains information about Telegram Passport data shared with the bot by
 * the user.
 */
export type PassportData
{

  /**
   * Array with information about documents and other Telegram Passport
   * elements that was shared with the bot
   */
  data: EncryptedPassportElement[];

  /**
   * Encrypted credentials required to decrypt the data
   */
  credentials: EncryptedCredentials;

}

/**
 * This object represents a file uploaded to Telegram Passport. Currently
 * all Telegram Passport files are in JPEG format when decrypted and don't
 * exceed 10MB.
 */
export type PassportFile
{

  /**
   * Unique identifier for this file
   */
  file_id: String;

  /**
   * File size
   */
  file_size: Integer;

  /**
   * Unix time when the file was uploaded
   */
  file_date: Integer;

}

/**
 * Contains information about documents or other Telegram Passport elements
 * shared with the bot by the user.
 */
export type EncryptedPassportElement
{

  /**
   * Element type. One of `personal_details`, `passport`, `driver_license`,
   * `identity_card`, `internal_passport`, `address`, `utility_bill`,
   * `bank_statement`, `rental_agreement`, `passport_registration`,
   * `temporary_registration`, `phone_number`, `email`.
   */
  type: String;

  /**
   * Optional. Base64-encoded encrypted Telegram Passport element data
   * provided by the user, available for `personal_details`, `passport`,
   * `driver_license`, `identity_card`, `internal_passport` and `address`
   * types. Can be decrypted and verified using the accompanying EncryptedCredentials.
   */
  data: String;

  /**
   * Optional. User's verified phone number, available only for
   * `phone_number` type
   */
  phone_number: String;

  /**
   * Optional. User's verified email address, available only for `email` type
   */
  email: String;

  /**
   * Optional. Array of encrypted files with documents provided by the user,
   * available for `utility_bill`, `bank_statement`, `rental_agreement`,
   * `passport_registration` and `temporary_registration` types. Files can be
   * decrypted and verified using the accompanying EncryptedCredentials.
   */
  files: PassportFile[];

  /**
   * Optional. Encrypted file with the front side of the document, provided
   * by the user. Available for `passport`, `driver_license`, `identity_card`
   * and `internal_passport`. The file can be decrypted and verified using
   * the accompanying EncryptedCredentials.
   */
  front_side: PassportFile;

  /**
   * Optional. Encrypted file with the reverse side of the document, provided
   * by the user. Available for `driver_license` and `identity_card`. The
   * file can be decrypted and verified using the accompanying EncryptedCredentials.
   */
  reverse_side: PassportFile;

  /**
   * Optional. Encrypted file with the selfie of the user holding a document,
   * provided by the user; available for `passport`, `driver_license`,
   * `identity_card` and `internal_passport`. The file can be decrypted and
   * verified using the accompanying EncryptedCredentials.
   */
  selfie: PassportFile;

}

/**
 * Contains data required for decrypting and authenticating
 * EncryptedPassportElement. See the Telegram Passport Documentation for a
 * complete description of the data decryption and authentication processes.
 */
export type EncryptedCredentials
{

  /**
   * Base64-encoded encrypted JSON-serialized data with unique user's
   * payload, data hashes and secrets required for EncryptedPassportElement
   * decryption and authentication
   */
  data: String;

  /**
   * Base64-encoded data hash for data authentication
   */
  hash: String;

  /**
   * Base64-encoded secret, encrypted with the bot's public RSA key, required
   * for data decryption
   */
  secret: String;

}

/**
 * Informs a user that some of the Telegram Passport elements they provided
 * contains errors. The user will not be able to re-submit their Passport
 * to you until the errors are fixed (the contents of the field for which
 * you returned the error must change). Returns True on success.
 *
 * Use this if the data submitted by the user doesn't satisfy the standards
 * your service requires for any reason. For example, if a birthday date
 * seems invalid, a submitted document is blurry, a scan shows evidence of
 * tampering, etc. Supply some details in the error message to make sure
 * the user knows how to correct the issues.
 */
export type setPassportDataErrors
{

  /**
   * User identifier
   */
  user_id: Integer;

  /**
   * A JSON-serialized array describing the errors
   */
  errors: PassportElementError[];

}

/**
 * This object represents an error in the Telegram Passport element
VM258:38 /**
 * Your bot can offer users HTML5 games to play solo or to compete against
 * each other in groups and one-on-one chats. Create games via @BotFather
 * using the /newgame command. Please note that this kind of power requires
 * responsibility: you will need to accept the terms for each game that
 * your bots will be offering.
 *
 * Use this method to send a game. On success, the sent Message is returned.
 */
export type sendGame
{

  /**
   * Unique identifier for the target chat
   */
  chat_id: Integer;

  /**
   * Short name of the game, serves as the unique identifier for the game.
   * Set up your games via Botfather.
   */
  game_short_name: String;

  /**
   * Sends the message silently. Users will receive a notification with no sound.
   */
  disable_notification: Boolean;

  /**
   * If the message is a reply, ID of the original message
   */
  reply_to_message_id: Integer;

  /**
   * A JSON-serialized object for an inline keyboard. If empty, one ‘Play
   * game_title’ button will be shown. If not empty, the first button must
   * launch the game.
   */
  reply_markup: InlineKeyboardMarkup;

}

/**
 * This object represents a game. Use BotFather to create and edit games,
 * their short names will act as unique identifiers.
 */
export type Game
{

  /**
   * Title of the game
   */
  title: String;

  /**
   * Description of the game
   */
  description: String;

  /**
   * Photo that will be displayed in the game message in chats.
   */
  photo: PhotoSize[];

  /**
   * Optional. Brief description of the game or high scores included in the
   * game message. Can be automatically edited to include current high scores
   * for the game when the bot calls setGameScore, or manually edited using
   * editMessageText. 0-4096 characters.
   */
  text: String;

  /**
   * Optional. Special entities that appear in text, such as usernames, URLs,
   * bot commands, etc.
   */
  text_entities: MessageEntity[];

  /**
   * Optional. Animation that will be displayed in the game message in chats.
   * Upload via BotFather
   */
  animation: Animation;

}

/**
 * A placeholder, currently holds no information. Use BotFather to set up
 * your game.
 *
 * Use this method to set the score of the specified user in a game. On
 * success, if the message was sent by the bot, returns the edited Message,
 * otherwise returns True. Returns an error, if the new score is not
 * greater than the user's current score in the chat and force is False.
 */
export type CallbackGameexport type setGameScore
{

  /**
   * User identifier
   */
  user_id: Integer;

  /**
   * New score, must be non-negative
   */
  score: Integer;

  /**
   * Pass True, if the high score is allowed to decrease. This can be useful
   * when fixing mistakes or banning cheaters
   */
  force: Boolean;

  /**
   * Pass True, if the game message should not be automatically edited to
   * include the current scoreboard
   */
  disable_edit_message: Boolean;

  /**
   * Required if inline_message_id is not specified. Unique identifier for
   * the target chat
   */
  chat_id: Integer;

  /**
   * Required if inline_message_id is not specified. Identifier of the sent message
   */
  message_id: Integer;

  /**
   * Required if chat_id and message_id are not specified. Identifier of the
   * inline message
   */
  inline_message_id: String;

}

/**
 * Use this method to get data for high score tables. Will return the score
 * of the specified user and several of his neighbors in a game. On
 * success, returns an Array of GameHighScore objects.
 */
export type getGameHighScores
{

  /**
   * Target user id
   */
  user_id: Integer;

  /**
   * Required if inline_message_id is not specified. Unique identifier for
   * the target chat
   */
  chat_id: Integer;

  /**
   * Required if inline_message_id is not specified. Identifier of the sent message
   */
  message_id: Integer;

  /**
   * Required if chat_id and message_id are not specified. Identifier of the
   * inline message
   */
  inline_message_id: String;

}

/**
 * This object represents one row of the high scores table for a game.
 */
export type GameHighScore
{

  /**
   * Position in high score table for the game
   */
  position: Integer;

  /**User
   */
  user: User;

  /**Score
   */
  score: Integer;

}


Add the hyper-yes plugin.

https://github.com/albertjan/hyper-yes and https://www.npmjs.com/package/hyper-yes
A plugin that takes care of answering 'Terminate batch job (y/n)'.

I've pushed a new 1200x800 gif to the hyper-yes repository

👋


C Engineer Remastered

Hello there, I'm new to coding and just wanted to add my own epic sfx to the already great C Engineer voice so I did use a lot of GPT to make this work.
The biggest change in this project I did was obviously remastering the sounds with some reverb and adding extra motivating jingles, but I also optimized the properties tab a little bit better personally. Please ignore the (added skill/boss pet drops because I couldn't figure out how to make that work.)  I'm not sure if this is a request to update your plugin or what, because I'm just trying to upload it onto runelite, but if you like the plugin and want to merge the two, you are more than welcome to do so :)

If you're trying to get a plugin into the plugin hub you need to submit a PR to the https://github.com/runelite/plugin-hub repo. I'm not sure they'd accept a plugin with so few changes from one that already exists, but you could also build a shadow jar to use the plugin yourself even without publishing it to the hub. You can get more information about that by asking in the RuneLite discord.


Don't import int64 js module if it's not required

This imports the int64 module only if it's required.
This is so that strict compilation will not raise an error on that import.

Thanks Jamie!


Add k8gb delivery scenario to podtato head

CNCF App Delivery SIG maintains a nice demo app of https://github.com/podtato-head/podtato-head
Extending delivery scenarios with k8gb example will be beneficial for the project and visibility

Interested to work on it from next week.

@AugustasV amazing!

Where I should start, lost littlebit. I will try to create Helm delivery scenario, locally I am able to deploy using deploy-full-local-setup script.

no demand for this one at the moment. Closing


The default int type of numpy in arithmetic_coding.py

I passed all tests of arithmetic_coding.py on my MacBook but failed 3 on my Windows desktop.
And I found the problem is about the default int type of Numpy (I think it changes between different systems).
The default type on my MacBook is int64, while it is int32 on my desktop.
Since it is difficult to change the default int type of Numpy, it is better to add "dtype=np.int64" in line 197 of arithmetic_coding.py, and it will work well on those System32.
 search_list = (
            low + (np.array(list(freqs.cumulative_freq_dict.values())) * rng) // freqs.total_freq
        )”

To
 search_list = (
            low + (np.array(list(freqs.cumulative_freq_dict.values()), dtype=np.int64) * rng) // freqs.total_freq
        )”

Hi, thanks for bringing this up. Could you make a pull request for the same? Thanks


Support for DoT / DoH directly with Android 9+

Android 9+ supports DoT with domain-name in the settings, DoH is supported as of Android 13 https://www.xda-developers.com/android-13-dns-https-support/
It would be really great to facilitate support for this directly so I don't have to use Wireguard!

You don't want to open up your DNS server to the whole world :\


⚠ Catalog API Endpoint has degraded performance

In aa79f3e, Catalog API Endpoint (https://catalog.roblox.com/v1/bundles/details?bundleIds=192) experienced degraded performance:

HTTP code: 200
Response time: 1670 ms

Resolved: Catalog API Endpoint performance has improved in b93e208 after 102 days, 20 hours, 4 minutes.


i18n(pt-PT): update outdated pages

Description

Updated getting-started.mdx community-content.mdx and plugins.mdx

Lunaria Status Overview
🌕 This pull request will trigger status changes.

Learn more
By default, every PR changing files present in the Lunaria configuration's files property will be considered and trigger status changes accordingly.
You can change this by adding one of the keywords present in the ignoreKeywords property in your Lunaria configuration file in the PR's title (ignoring all files) or by including a tracker directive in the merged commit's description.

Tracked Files

Locale
File
Note

pt-pt
getting-started.mdx
Localization changed, will be marked as complete.

pt-pt
resources/community-content.mdx
Localization changed, will be marked as complete.

pt-pt
resources/plugins.mdx
Localization changed, will be marked as complete.

Warnings reference

Icon
Description

🔄
The source for this localization has been updated since the creation of this pull request, make sure all changes in the source have been applied.

Thank you for the update @rgilsimoes! Just spotted a couple of small typos.

Darn... dislexia hit me hard on Starlight :-)


When infinite=true, first items moves to bottom and not show up

My code:

====================================================================
my Slider has 3 items
when I set infinite = false, everything works fine,

when I set infinite = true, the first item moves to bottom and disappear

====================================================================
react-slick version: 0.25.2

Just an update:
In the react-slick doc, when infinite=true, there will be some div created with 'slick-cloned' class (there are 6 items so there will be 6 'slick-cloned' div) :

However in my project, there are no 'slick-cloned' div created:

Please help me with my problem.


How to get the response as email sending? E.g. (Delivery status of email: Sent Successful, Email Rejected)

How to get the response as email sending? I have checked the source, but I cannot get any idea on it.
e.g. Rejected, Sent and Failed for # delivery status of email.
	ExchangeService service = new ExchangeService(ExchangeVersion.Exchange2010_SP2);
	ExchangeCredentials credentials = new WebCredentials(senderAddress, senderPassword);
	try{
	service.setCredentials(credentials);
	service.setUrl(new URI(exchangeURL));

	EmailMessage msg= new EmailMessage(service);
	msg.setSubject("Hello world!");
	msg.setBody(MessageBody.getMessageBodyFromText("

Sent using the EWS Java API.	This book..

"));
	try{
	msg.getToRecipients().add("testqq1@idddnt.hkex.hk");
	//msg.send();
	msg.sendAndSaveCopy();
	}catch (Exception ex){
		ex.printStackTrace();
	}

I also face this issue. Could you resolve it?

me too


The images in the blog.html is not shown properly

(Maybe changes in the image path must be checked)

Okay i went through the code, can you let me know which image is to be fixed?


Final Product

Epic
Combines Web Application #1 and App Functionality #2 to make final product of web app that provides easy query access to existing graph databases.
Epics Needed

[x] Epic #1 (Web Application)
[x] Epic #2 (App Functionality)

Tasks

[x] #13
[x] #14
[x] #15
[x] #16
[x] #17

Done.


az rest inconsistent result in Github actions

az feedback auto-generates most of the information requested below, as of CLI version 2.0.62

Related command
az rest
Describe the bug
Running the following command locally generates expected results, but when I run a github action, it results in only one resource group.
az rest \
  --method get \
  --url "https://management.azure.com/subscriptions/$subscription_id/resourceGroups" \
  --url-parameters api-version=2020-06-01 \$expand=createdTime

To Reproduce

Create a subscription
Create several resource groups in portal
Follow the instruction here to setup Github actions such as:

name: Azure Resource manager
on:
  push:
    branches:
      - 'main'

permissions:
  id-token: write
  contents: read
jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
    - name: 'Az CLI login'
      uses: azure/login@v1
      with:
          client-id: ${{ secrets.AZURE_CLIENT_ID }}
          tenant-id: ${{ secrets.AZURE_TENANT_ID }}
          subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

    - name: 'Resource groups'
      run: |
        az rest \
          --method GET \
          --url "https://management.azure.com/subscriptions/$subscription_id/resourceGroups" \
          --url-parameters api-version=2019-10-01 \$expand=createdTime \$select=name,createdTime > resource-groups.json
        more resource-groups.json
      env:
        subscription_id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

Compare local results with the workflow. Here is my repo where I reproduced this bug.

Expected behaviour
The command must return all the resource groups in the subscription. However that is not the case. For the example in the aforementioned repo, locally I receive the following:
{
  "value": [
    {
      "createdTime": "2023-04-04T11:14:42.4714202Z",
      "id": "/subscriptions/***/resourceGroups/rg-main",
      "location": "westeurope",
      "name": "rg-main",
      "properties": {
        "provisioningState": "Succeeded"
      },
      "type": "Microsoft.Resources/resourceGroups"
    },
    {
      "createdTime": "2023-04-14T13:04:54.5605494Z",
      "id": "/subscriptions/***/resourceGroups/rg-testwest",
      "location": "westeurope",
      "name": "rg-testwest",
      "properties": {
        "provisioningState": "Succeeded"
      },
      "tags": {
        "duration": "10"
      },
      "type": "Microsoft.Resources/resourceGroups"
    },
    {
      "createdTime": "2023-04-14T10:57:33.4232716Z",
      "id": "/subscriptions/***/resourceGroups/test-new",
      "location": "southcentralus",
      "name": "test-new",
      "properties": {
        "provisioningState": "Succeeded"
      },
      "tags": {
        "duration": "10"
      },
      "type": "Microsoft.Resources/resourceGroups"
    },
    {
      "createdTime": "2023-04-05T20:22:57.6056543Z",
      "id": "/subscriptions/***/resourceGroups/rg-test",
      "location": "eastus",
      "name": "rg-test",
      "properties": {
        "provisioningState": "Succeeded"
      },
      "tags": {
        "duration": "6"
      },
      "type": "Microsoft.Resources/resourceGroups"
    }
  ]
}

However the pipeline generates the following (see also here in step: Remove resource group):
{
  "value": [
    {
      "createdTime": "2023-04-04T11:14:42.4714202Z",
      "id": "/subscriptions/***/resourceGroups/rg-main",
      "location": "westeurope",
      "name": "rg-main",
      "properties": {
        "provisioningState": "Succeeded"
      },
      "type": "Microsoft.Resources/resourceGroups"
    }
  ]
}

Environment summary
My local machine is macOS Ventura 13.2 with the following az version:
azure-cli                         2.47.0 *

core                              2.47.0 *
telemetry                          1.0.8

Extensions:
resource-graph                     2.1.0

Dependencies:
msal                              1.20.0
azure-mgmt-resource               22.0.0

Python location '/opt/homebrew/Cellar/azure-cli/2.47.0/libexec/bin/python'
Extensions directory '/Users/naeeme/.azure/cliextensions'

Python (Darwin) 3.10.11 (main, Apr  7 2023, 07:24:53) [Clang 14.0.0 (clang-14<IP_ADDRESS>)]

Legal docs and information: aka.ms/AzureCliLegal

As above, the workflow runs on an Ubuntu machine with:
azure-cli                         2.48.1

core                              2.48.1
telemetry                          1.0.8

Extensions:
azure-devops                      0.26.0

Dependencies:
msal                              1.20.0
azure-mgmt-resource               22.0.0

Python location '/opt/az/bin/python3'

Extensions directory '/opt/az/azcliextensions'

Python (Linux) 3.10.10 (main, Apr 25 2023, 04:23:10) [GCC 11.3.0]

Legal docs and information: aka.ms/AzureCliLegal

Additional context

Thank you for opening this issue, we will look into it.

Hi @Naeemedmo,
I successfully ran the workflow you shared with all the resource groups in the subscription returned. The issue you encountered could be due to the azure/login action using a service principal that's set to resource-group scope. To resolve this, consider creating a service principal at the subscription scope and refreshing the Azure credentials in your GitHub repo.


Lineage with 3+ dependencies

Is your feature request related to a problem? Please describe.
Currently, the max downstream/upstream depth is 3, and users are not able to view the entire lineage when we retrieve it from dbt

Describe the solution you'd like
A clear and concise description of what you want to happen.
Would love to have an option "3+" as a choice to be able to view all dependencies, such as what is implemented in datahub here
https://datahubproject.io/docs/lineage/lineage-feature-guide/#editing-from-lineage-tab

This feature is supported on newer releases of OM. You can explore the lineage view in the sandbox https://sandbox.open-metadata.org/table/sample_data.ecommerce_db.shopify.raw_customer/lineage
Closing it for now since we are already presenting all the information


Enable vulnerability reporting via GitHub

It looks like it is now possible to report vulnerabilities directly through the GitHub UI (h/t @hamnis). Thoughts on enabling this across the orgs?
https://docs.github.com/en/code-security/security-advisories/guidance-on-reporting-and-writing/privately-reporting-a-security-vulnerability
cc @typelevel/security

:+1: Finally, Microsoft!
It's not 100% clear to me who receives these reports.  The documentation keeps informally saying "you" and "repository maintainers".  This page seems most authoritative:

Who can use this feature
Anyone with admin permissions to a repository can see, review, and manage privately-reported vulnerabilities for the repository.

In practice, that would mostly be Steering, who could loop in Security.  That's fine.
I don't see a way to roll it out at the org level, so there'd be some tedious clicking.  Since it's a Beta feature, and since it's not easy to reliably maintain at the org level, I would propose we make this the preferred way, but not tear down the e-mail backstop.


add PyModule::from_pyc (#3482)

Adds a PyModule::from_pyc function. See #3482 and #3480.

I have no idea how to fix the codecov/patch test. Help would be appreciated

I realize I never asked why you want this. What is your use case for embedding and executing .pyc files? The documentation should cover why someone would want to to do this (rather than use a different PyModule api or bundling their files with PyOxidizer).
I'm not familiar with .pyc files other than knowing it's some kind of bytecode format. My concerns are:

I couldn't find guarantees about the .pyc format (this is probably why there is no C api function for running one). This means that we can't rely on it not changing, and this also means we can't just do what the (private) internals of the python interpreter do.
The format depends on the Python version being used, this means you can't use this when you are running a different Python than the one the bytecode is compiled for. In other words - this is a gotcha for people using this and distributing their modules.

I do feel quite strongly that we should not ship a .pyc snippet in the repo. As you rightly point out in the test suite, it's dangerous to pass untrusted code to this function. We may be comfortable with our own asset but downstream packagers may not be.

If we release this from_pyc function we are effectively encouraging users to ship pyc blobs with their modules - I'm not comfortable with that either.

Given that all of us are feeling uncomfortable about security connotations of this one way or another, perhaps that is suggesting this is better to not merge and leave for downstream users to implement themselves if desired? Seems like we already expose the APIs to do so in pyo3-ffi.

I'm closing this per the above. Thank you for your efforts.


Add Pusher

Fixes #150
This means that metrics can be updated live on the dashboard as they're added. Works in the wild on my branch, the only issue is adding another external dependency. Not sure if this will carry over to everyone else's Bothan. Will need to check.

I've poked the review app on heroku, let's see if this works.

The test app has a pusher addon added: https://dashboard.heroku.com/apps/odi-metrics-api-pr-157

Closing in favour of #158


Add --color and --no-color options

We want to allow people to force the use or non-use of color when
running scss-lint. This commit does this by extracting the logging into
a Logger class and adding --color and --no-color options.
For this code, I essentially brought over the same stuff that was done
in HamlLint.
Addresses #364

Ack, it looks like this might not entirely do the job, since default reporter still adds color via the rainbow gem. Since the reporters in this project return strings instead of printing them, and since Logger prints things, how do you think we should tackle this @sds?

I think I'm just going to add a logger argument to the Reporter initialize and expose some methods for coloring text on the logger.

Thanks for the pull request, @lencioni.
Yes, we'll need to rewrite the reporters to use the Logger class, as all output should be delegated to it.

Alright, I just pushed a new version. Let me know what you think!

Thanks so much for implementing this, @lencioni!

\o/


Add ListenAndServeTLS

Calling tls.Listen() and passing that connection to Serve() does work (as expected). I just thought this provided a simpler interface for users. However, we should also offer a client for this (obviously), so I'm just cleaning that up now and will push soon (to this branch).
This is in reference to issue #13 .

Comments from the review on Reviewable.io

server.go, line 51 [r1] (raw file):
what if we make this cert, err := tls.LoadX509KeyPari(certFile, keyFile), and then (see line 56) ...

server.go, line 56 [r1] (raw file):
... and then we make this l, err := tls.Listen(network, laddr, &tls.Config{Certificates: []tls.Certificate{cert}})
the reason being that then we don't need the var block at the top (or line 50), since err gets shadowed with this call anyway.

Comments from the review on Reviewable.io
Reviewed files:

client.go @ r1
server.go @ r1

Comments from the review on Reviewable.io

server.go, line 56 [r1] (raw file):
I'm fine with that, I was just following the example in tls.Dial().

Comments from the review on Reviewable.io

server.go, line 51 [r1] (raw file):
Done.

server.go, line 56 [r1] (raw file):
Done.

Comments from the review on Reviewable.io
Reviewed files:

server.go @ r2


AntreaProxy feature is missing in pipeline doc

OVS Pipeline document is missing AntreaProxy.

Thanks Kobi. I think we should make sure we have updated the doc by the time Antrea proxy is enabled by default.

Looks like we didn't have time to update the documentation for AntreaProxy, even though it is enabled by default in Antrea v0.11


logger doesn't compile

I created a new project via stack new stacktest, added logger as a extra-dep in stack.yml, added logger as a dependency in the cabal file, and tried to build. Didn't work, got this error:
~/s/stacktest ❯❯❯ stack build                       Sun Mar 27 12:54:21 PDT 2016
logger-<IP_ADDRESS>: configure
logger-<IP_ADDRESS>: build
Progress: 1/2
--  While building package logger-<IP_ADDRESS> using:
      /home/scott/.stack/setup-exe-cache/x86_64-openbsd/setup-Simple-Cabal-<IP_ADDRESS>-ghc-7.10.3 --builddir=.stack-work/dist/x86_64-openbsd/Cabal-<IP_ADDRESS> build --ghc-options " -ddump-hi -ddump-to-file"
    Process exited with code: ExitFailure 1
    Logs have been written to: /home/scott/src/stacktest/.stack-work/logs/logger-<IP_ADDRESS>.log

    Configuring logger-<IP_ADDRESS>...
    Building logger-<IP_ADDRESS>...
    Preprocessing library logger-<IP_ADDRESS>...

    /tmp/stack1963/logger-<IP_ADDRESS>/src/System/Log/Filter.hs:3:14: Warning:
        -XOverlappingInstances is deprecated: instead use per-instance pragmas OVERLAPPING/OVERLAPPABLE/OVERLAPS

    /tmp/stack1963/logger-<IP_ADDRESS>/src/System/Log/Format.hs:3:14: Warning:
        -XOverlappingInstances is deprecated: instead use per-instance pragmas OVERLAPPING/OVERLAPPABLE/OVERLAPS

    /tmp/stack1963/logger-<IP_ADDRESS>/src/System/Log/Data.hs:8:14: Warning:
        -XOverlappingInstances is deprecated: instead use per-instance pragmas OVERLAPPING/OVERLAPPABLE/OVERLAPS
    [ 1 of 15] Compiling System.Log.Log   ( src/System/Log/Log.hs, .stack-work/dist/x86_64-openbsd/Cabal-<IP_ADDRESS>/build/System/Log/Log.o )
    [ 2 of 15] Compiling System.Log.Data  ( src/System/Log/Data.hs, .stack-work/dist/x86_64-openbsd/Cabal-<IP_ADDRESS>/build/System/Log/Data.o )
    ghc: /home/scott/.stack/snapshots/x86_64-openbsd/lts-5.9/7.10.3/lib/x86_64-openbsd-ghc-7.10.3/atomic-primops-<IP_ADDRESS>-KJ263HDUG22HNNccH10Gth/HSatomic-primops-<IP_ADDRESS>-KJ263HDUG22HNNccH10Gth.o: unknown symbol `store_load_barrier'
    ghc: unable to load package `atomic-primops-<IP_ADDRESS>'
~/s/stacktest ❯❯❯

Hello @bonds!
I'm sorry I was out of office for a month (a really long business trip). I'll check that out. Anyway the error seems really strange. Have you tried digging what has caused it? Anyway, there will be new version of haskell-logger soon, I'm working on it in a very limited timeframe right now.

No worries, I know what its like to be busy. ;) I haven't tried digging around more, I'm just using a different logging lib for now.


Update d8-woonsocket.yaml

Update and change meeting time from 6 pm to 8 pm.

This looks like another good change to me. I wonder why Jamey N. isn't reviewing/approving any of these changes ... :/


Fixed potential crash cause + Version Bump

If you had 2 subscribed objects to the same topic, with the same method name, the generated Receiver class would only cast to the first one registered and would throw a ClassCastException whenever the second listener would be registered.

Yes, you should know that, this is basic java :D

having the same issue
please know how to correctly write a code on java and fix something as easy as this issue


[FR] enable github discussions feature

hi,
any chance you might enable github's Discussions feature for this repo, so people can ask questions for general support and/or to clarify things prior to creating an issue report? It would probably cut down on invalid bug reports, questions in the issue tracker, and help new users get started. Users could eventually help each other, and save owlkettle devs some time, etc.
I'm not in favor of projects using ephemeral chat for support because the same questions get asked and answered over and over again, and i don't like bothering people with something basic that has already been asked and could have been documented by forum software.
thanks

Good idea. I think it should be enabled now. I also think that having an official channel for asking & answering questions that also allows searching the existing answers is quite useful. It might currently take some time for me to respond though  (same goes for issues as well), since I am currently quite busy irl.

Good idea. I think it should be enabled now. I also think that having an official channel for asking & answering questions that also allows searching the existing answers is quite useful.

great!

It might currently take some time for me to respond though (same goes for issues as well), since I am currently quite busy irl.

understood. thanks for the warning. :)


Basic integration tests

With the new non-interactive mode command line parameter, we can now get some more useful integration tests working. This first PR adds two simple tests and a new command line parameter to set the log file output.

All good