class DDecorator(ContextDecorator):
    """To use:
    DD = DDecorator()
    with DD:
        your pl stuff with shown cols rows
    # or
    DD(your_df) -> display(your_df)
    """

    def __init__(self, ncols=-1, nrows=-1):
        self.ncols = ncols
        self.nrows = nrows

        def_state = pl.Config.state()
        # print(def_state)
        self.d_ncols = def_state["POLARS_FMT_MAX_COLS"]
        self.d_nrows = def_state["POLARS_FMT_MAX_ROWS"]

    def __call__(self, df, all: bool = False, ncols=None, nrows=None):
        ncols = self.ncols if ncols is None else ncols
        nrows = self.nrows if nrows is None else nrows
        if all:
            ncols = -1
            nrows = -1
        with pl.Config(set_tbl_cols=ncols, set_tbl_rows=nrows):
            display(df)

    def __enter__(self):
        pl.Config.set_tbl_rows(self.nrows)
        pl.Config.set_tbl_cols(self.ncols)
        return self

    def __exit__(self, *exc):
        # print("Finishing")
        # default vals
        pl.Config.set_tbl_rows(self.d_nrows)
        pl.Config.set_tbl_cols(self.d_ncols)
        return False


DD = DDecorator(nrows=30, ncols=30)


def describe(df):
    # with DDecorator(ncols=-1):
    with pl.Config(set_tbl_cols=-1):
        itables.show(
            df.describe(percentiles=None), fixedColumns={"start": 1}, scrollX=True
        )

df = pl.read_csv("docs/assets/data/my_many_files_*.csv")

def stack_types(
    df: pl.DataFrame,
    types: Sequence[str] = ("l", "t"),
    metrics: Sequence[str] = ("num_words", "num_chars"),
    id_cols: Sequence[str] = (),
    type_key="type",
) -> pl.DataFrame:
    """Stack prefixed metric columns into long format."""
    return pl.concat(
        [
            df.select(
                *id_cols,
                *(c(f"{t}_{m}").alias(m) for m in metrics),
                type=pl.lit(t),
            )
            for t in types
        ]
    ).rename({"type": type_key})

# If multiple fit then the first one is picked
df.with_columns(
    pl.when(pl.col.foo > 2)
    .then(1)
    .when(pl.col.bar > 2)
    .then(4)
    .otherwise(-1)
    .alias("val")
)
df.with_columns(
...     when1 = pl.col.foo > 2,
...     then1 = 1,
...     when2 = pl.col.bar > 2,
...     then2 = 4,
...     otherwise = -1
... )

df.select("some_col", new_col2="col2")

.with_columns(
    pl.format(
        "{} [{}]",
        c(LLM_MODEL),
        c(THINKING).cast(pl.String).fill_null("None"),
    ).alias(MODEL_VARIANT)
)

# when ...
pl.concat_str(
	[c(LLM_MODEL), c(THINKING)],
	separator="/",
	ignore_nulls=True,  # single None doesn't None the entire row
).alias(MODEL_VARIANT)
# ...is not enough

# ...or even this to avoid the [{}] part if thinking is null
.with_columns(
	pl.when(c(THINKING).is_null())
	.then(c(LLM_MODEL))
	.otherwise(pl.format("{} [{}]", c(LLM_MODEL), c(THINKING)))
	.alias(MODEL_VARIANT)
)

# this will never work:
(pl.col(effect_col(m)) < 0).count().alias("n_worsened"),
(pl.col(effect_col(m)) < 0).len().alias("n_worsened"),
# do this insead
(pl.col(effect_col(m)) < 0).sum().alias("n_worsened"),

sns.catplot(..)
plt.title("mytitle")

g = sns.catplot(...)

g.set_axis_labels("Width", "Equals (acc.)")

# # not needed if you do tight_layout()
# g.fig.subplots_adjust(top=0.85)

g.fig.suptitle("Masking and breaking words makes everything worse")

plt.tight_layout()
plt.show()

  
# Plot scatter plot
g = sns.relplot(data = tips , x = "total_bill" , 
                y = "tip" , col = "time" , 
                hue = "day" , style = "day" , 
                kind = "scatter" )

# Title for the complete figure
g.fig.suptitle("Tips by time of day" ,
               fontsize = 'x-large' , 
               fontweight = 'bold' )

# Adjust subplots so that titles don't overlap
g.fig.subplots_adjust( top = 0.85 )

# Set x-axis and y-axis labels
g.set_axis_labels( "Tip" , "Total Bill (USD)" )

mim_locale = Locale.EN
generic = Generic(locale=mim_locale)
job = generic.person.occupation()

uv run complexipy src --failed --suggest-refactors

[tool.poe.tasks]
test   = "pytest"
test-now = "pytest -m now --pdb"
check-complexity = "uv run complexipy src --failed --suggest-refactors --max-complexity 15"

ty = "uv run ty check src --output-format concise"
fty = "uv run ty check src --output-format concise --fix"

ruff = "uv run ruff check src"
fruff = "uv run ruff check src --fix"
fruff-unsafe = "uv run ruff check src --fix --unsafe-fixes"

black = "uv run black src --check"
fblack = "uv run black src"

Katheryn McDaniel:
    position: president
    address:
        > 138 Almond Street
        > Topeka, Kansas 20697
    phone:
        cell: 1-210-555-5297
        home: 1-210-555-8470
            # Katheryn prefers that we always call her on her cell phone.
    email: KateMcD@aol.com
    additional roles:
        - board member

[tool.hatch.build.targets.sdist]
exclude = [
  "tests/"
]

# before
-rw-r--r--  1 sh sh 156M Jul 13 13:20 pkg-9.2.0.tar.gz
# after
-rw-r--r--  1 sh sh 8.3M Jul 13 13:15 pkg-9.3.0.tar.gz

# yay!

PYTHONPROFILEIMPORTTIME=True uv run my_program.py

kubectl get node node-name -o template  --template='{{ index .metadata.annotations "management.cattle.io/pod-requests" }}' 

#  | jq '.["nvidia.com/gpu"]' 

k get node nodename -o template  --template='{"requests": {{ index .metadata.annotations "management.cattle.io/pod-requests" }}, "limits": {{ index .metadata.annotations "management.cattle.io/pod-requests" }}, "total": {"nvidia.com/gpu": {{ index .metadata.labels "nvidia.com/gpu.count" }} } }' | jq .

{
  "requests": {
    "cpu": "19795m",
    "memory": "7450Mi",
    "nvidia.com/gpu": "1",
    "pods": "37"
  },
  "limits": {
    "cpu": "19795m",
    "memory": "7450Mi",
    "nvidia.com/gpu": "1",
    "pods": "37"
  },
  "total": {
    "nvidia.com/gpu": 1
  }
}

k get node nodename -o template  --template='{"requests": {{ index .metadata.annotations "management.cattle.io/pod-requests" }}, "limits": {{ index .metadata.annotations "management.cattle.io/pod-requests" }}, "total": {"nvidia.com/gpu": {{ index .metadata.labels "nvidia.com/gpu.count" }} } }' | jq '. | [.requests["nvidia.com/gpu"], .limits["nvidia.com/gpu"],  .total["nvidia.com/gpu"] | tonumber]' -c

# -> [2,1,4]

# k get nodes -A  -o yaml > /tmp/xxx
# let $d = open /tmp/xxx.yaml
k get nodes -A  -o yaml | from yaml | let $d

$d.items | get metadata | select name labels."nvidia.com/gpu.count"? annotations."management.cattle.io/pod-limits"? annotations."management.cattle.io/pod-requests"? | rename name gpucount limits requests   | update limits {|| from json} | update requests  {|| from json} | update limits {|$i| $i.limits."nvidia.com/gpu"?} | update requests {|$i| $i.requests."nvidia.com/gpu"?}

alias ,isodate='date +%F'

function ,blist -d "search and show bitwarden credentials"
    command bw list items --search "$argv" | jq '.[].login | [.username, .password]' -c
end

function ,bcp  -d "copy password of the first matching bitwarden item"
	command bw list items --search $argv | jq .[0].login.password -r | xc
	echo "copied password for '$argv'"
end

# etc, I see potential here!

# Source - https://stackoverflow.com/a/60451617
# Posted by Chris Doyle
# Retrieved 2026-04-09, License - CC BY-SA 4.0

from enum import Enum
class Shake(Enum):
    VANILLA = "vanilla"
    CHOCOLATE = "choc"
    COOKIES = "cookie"
    MINT = "mint"

dct = {i.name: i.value for i in Shake}
print(dct)

# from README
xh http://localhost:3000/users # resolves to http://localhost:3000/users
xh localhost:3000/users        # resolves to http://localhost:3000/users
xh :3000/users                 # resolves to http://localhost:3000/users
xh :/users                     # resolves to http://localhost:80/users
xh example.com                 # resolves to http://example.com
xh ://example.com              # resolves to http://example.com

# somewhere
def create() -> None:
    @ui.page('/a')
    def page_a():
        with theme.frame('- Page A -'):
            message('Page A')
            ui.label('This page is defined in a function.')
			
from somewhere import create

# Example 2: use a function to move the whole page creation into a separate file
# in main.py
function_example.create()

sel = ui.select(
	list(items),
	value=item,
)
with sel.add_slot("after"):
	ui.button(icon="description").props("flat no-caps").on(
		"click",
		lambda e: ui.navigate.to(f"/bp/{whatever}"),
	)

	table = ui.table()#...
    with table.add_slot("body-cell-ColumnName"):
        with table.cell("ColumnName"):
			# button w/ cell text
            ui.button().props(""" 
                             :innerHTML="props.value" 
                             """).on(
                "click",
                js_handler="() => emit(props.row.SomeColumnName)",
                handler=lambda e: ui.navigate.to(f"/sth/{e.args}"), # e.args is cell content
            )

				# conditionals
                .props(""" flat no-caps
                             :label="props.value !== 'N/A' ? props.value : ''"
                             """)


	# tooltips!
	with table.add_slot("body-cell-ISIN"):
		with table.cell("ISIN"):
			with ui.row().classes("items-stretch gap-0"):
u				ui.label().props(':textContent="props.value"')
				ui.tooltip().props("""
					center left
					:innerHTML="props.row.bp_link ? props.row.Basisprospekt : ''"
					:target="props.row.bp_link ? true : false"
				""")

with ui.link(target="/sd"):
	ui.button("Show", icon="description")

with ui.link(target=target_link).classes("no-underline"):
	ui.item_label("look ma no underline!")

# remove the floating prop and add one of these classes.
# Removing the prop is useful if using e.g. both top-left and top-right
# then they are on an identicafl height
ui.badge(faiss_dist_str, color="light-blue-10").props(
	# "floating"
).classes("absolute-top-left")

    ui.table(rows=rows).props("flat bordered").on(
        "row-click",
        lambda e: ui.navigate.to(f"/pr/{e.args[1]['ISIN']}"),
    )

async def show_new_quote():
    async with httpx.AsyncClient() as client:
        response = await client.get('https://zenquotes.io/api/quotes')
        quote = random.choice(response.json())['q']
    label.text = f'“{quote}”'

# (..) app.on_startup(setup)
# def setup():
# if CFG.debug_mode:
import asyncio
loop = asyncio.get_running_loop()
loop.set_debug(True)
loop.slow_callback_duration = 0.05

ui.upload(
	auto_upload=True, on_upload=lambda e: handle_upload(e)
).classes("max-w-full")

async def handle_upload(e: events.UploadEventArguments):
	with tempfile.NamedTemporaryFile(delete=False, prefix="uns") as tmp:
        save_path = Path(tmp.name)
        await e.file.save(save_path)
        return save_path

tabs.on_value_change(
	lambda e: load_bad_datasets() if e.value == "show_bad_datasets" else None
)
ui.tab("show_info", label="Info", icon="info")
ui.tab("show_bad_datasets", label="Bad Datasets", icon="error")
with ui.tab_panels(tabs, value="show_info").classes("w-full"):
with ui.tab_panel("show_info"):
	p_info()
with ui.tab_panel("show_bad_datasets"):
	bds = None
	async def load_bad_datasets():
		await asyncio.sleep(2)
		bad_ds = await get_bad_datasets()
		bds = show_pretty_json(bad_ds).classes("text-[8pt]")

element.run_method('focus')

# /// script
# dependencies = [
#   "rich",
#   "pdbpp", # ви цього варті
# ]
# ///

from rich import print
from rich.layout import Layout
from rich.table import Table
import argparse


def get_scores(tp, tn, fp, fn) -> dict[str, int | float | str | None]:
    """Calculate precision, recall, and F1 score from true positives, true negatives, false positives, and false negatives."""

    precision = tp / (tp + fp) if (tp + fp) > 0 else None
    recall = tp / (tp + fn) if (tp + fn) > 0 else None
    f1_score = (
        2 * (precision * recall) / (precision + recall)
        if precision is not None and recall is not None and (precision + recall) > 0
        else None
    )
    accuracy = (tp + tn) / (tp + tn + fp + fn) if (tp + tn + fp + fn) > 0 else None

    f_precision = float(f"{precision:.3f}") if precision is not None else "N/A"
    f_recall = float(f"{recall:.3f}") if recall is not None else "N/A"
    f_f1_score = float(f"{f1_score:.3f}") if f1_score is not None else "N/A"

    total_ds = tp + tn + fp + fn

    res = {
        "TP": tp,
        "TN": tn,
        "FP": fp,
        "FN": fn,
        "total": total_ds,
        "P ": f_precision,
        "R ": f_recall,
        "F ": f_f1_score,
        "A ": float(f"{accuracy:.3f}") if accuracy is not None else "N/A",
        # "A ": accuracy,
    }

    return res


def use_table(tp, tn, fp, fn, precision, recall, accuracy):
    total = tp + tn + fp + fn
    total_positive = tp + fn
    total_negative = tn + fp

    table_tn = Table()
    table_tn.add_column("TP", justify="center", style="green")
    table_tn.add_column("TN", justify="center", style="green underline italic")
    table_tn.add_column("FP", justify="center", style="red")
    table_tn.add_column("FN", justify="center", style="red underline italic")
    table_tn.add_column("sum/+/-", justify="right", style="cyan")
    table_tn.add_row(
        f"[bold green]{str(tp)}[/bold green]",
        f"[bold green]{str(tn)}[/bold green]",
        f"[bold red]{str(fp)}[/bold red]",
        f"[bold red]{str(fn)}[/bold red]",
        f"[bold cyan]{str(total)}[/bold cyan]="
        + f"[bold green]{str(total_positive)}[/bold green]+"
        + f"[bold red]{str(total_negative)}[/bold red]",
    )

    table = Table()

    table.add_column("", justify="right", style="cyan", no_wrap=True)
    table.add_column("Formula", justify="center", style="magenta")
    table.add_column("=>", justify="center", style="magenta")
    table.add_column("Value", justify="center", style="magenta")

    table.add_row(
        "",
        f"TP=[bold green]{str(tp)}[/bold green]",
        f"[bold yellow]{str(tp)}[/bold yellow]",
        "",
    )
    table.add_row(
        "Pre",
        "_" * (len(str(tp)) + len(str(fp)) + 6),
        "___",
        f"P=[bold yellow]{precision}[/bold yellow]",
    )
    table.add_row(
        "",
        f"TP=[bold green]{str(tp)}[/bold green] + FP=[bold red underline italic]{str(fp)}[/bold red underline italic]",
        f"[bold yellow]{str((tp + fp))}[/bold yellow]",
        "",
    )

    table.add_section()

    table.add_row(
        "",
        f"TP=[bold green]{str(tp)}[/bold green]",
        f"[bold yellow]{str(tp)}[/bold yellow]",
        "",
    )
    table.add_row("Rec", "______________", "", f"R=[bold yellow]{recall}[/bold yellow]")
    table.add_row(
        "",
        f"TP=[bold green]{str(tp)}[/bold green] + FN=[bold red underline italic]{str(fn)}[/bold red underline italic]",
        f"[bold yellow]{str((tp + fn))}[/bold yellow]",
        "",
    )

    table.add_section()
    # Accuracy
    table.add_row(
        "",
        f"TP=[bold green]{str(tp)}[/bold green] + TN=[bold green underline italic]{str(tn)}[/bold green underline italic]",
        f"[bold yellow]{str((tp + tn))}[/bold yellow]",
        "",
    )
    table.add_row(
        "Acc",
        "______________________________",
        "",
        f"A=[bold yellow]{accuracy}[/bold yellow]",
    )
    table.add_row(
        "",
        f"TP=[bold green]{str(tp)}[/bold green] + TN=[bold green underline italic]{str(tn)}[/bold green underline italic] + FP=[bold red]{str(fp)}[/bold red] + FN=[bold red underline italic]{str(fn)}[/bold red underline italic]",
        f"[bold yellow]{str((tp + tn + fp + fn))}[/bold yellow]",
        "",
    )

    print(table)
    print(table_tn)


def pretty_scores(scores: dict[str, int | float | str | None], draw=True):
    tp, tn, fp, fn = scores["TP"], scores["TN"], scores["FP"], scores["FN"]
    precision, recall, f1_score = scores["P "], scores["R "], scores["F "]
    accuracy = scores["A "]
    # print( f"| TP: {scores['TP']}, TN: {scores['TN']}, FP: {scores['FP']}, FN: {scores['FN']} | ")
    # print(
    #     f"| Precision: {scores['P ']}, Recall: {scores['R ']}, F1 Score: {scores['F ']} |"
    # )
    print(
        f"Precision: [bold cyan]P[/bold cyan] = [bold green]{tp}[/bold green] / ([bold green]{tp}[/bold green] + [bold red]{fp}[/bold red]) = [bold yellow]{precision}[/bold yellow]"
    )
    print(
        f"Recall: [bold cyan]R[/bold cyan] = [bold green]{tp}[/bold green] / ([bold green]{tp}[/bold green] + [bold red]{fn}[/bold red]) = [bold yellow]{recall}[/bold yellow]"
    )
    print(
        f"F1 Score: [bold cyan]F1[/bold cyan] = 2 * ([bold yellow]{precision}[/bold yellow] * [bold yellow]{recall}[/bold yellow]) / ([bold yellow]{precision}[/bold yellow] + [bold yellow]{recall}[/bold yellow]) = [bold magenta]{f1_score}[/bold magenta]"
    )
    print(
        f"Accuracy: [bold cyan]A[/bold cyan] = ([bold green]{tp}[/bold green] + [bold green]{tn}[/bold green]) / ([bold green]{tp}[/bold green] + [bold green]{tn}[/bold green] + [bold red]{fp}[/bold red] + [bold red]{fn}[/bold red]) = [bold yellow]{scores['A ']}[/bold yellow]"
    )

    # use_layout(tp, tn, fp, fn, precision, recall)
    use_table(tp, tn, fp, fn, precision, recall, accuracy)


def main():
    args = parse_args()
    # Example usage
    # tp = 100
    # tn = 50
    # fp = 10
    # fn = 5
    tp = args.tp
    tn = args.tn
    fp = args.fp
    fn = args.fn

    scores = get_scores(tp, tn, fp, fn)
    pretty_scores(scores)


def parse_args():
    parser = argparse.ArgumentParser(
        description="Calculate precision, recall, and F1 score."
    )
    # use positional arguments for tp, tn, fp, fn
    parser.add_argument("tp", type=int, help="True Positives", default=0)
    parser.add_argument("tn", type=int, help="True Negatives", default=0)
    parser.add_argument("fp", type=int, help="False Positives", default=0)
    parser.add_argument("fn", type=int, help="False Negatives", default=0)
    # parser.add_argument("--tp", type=int, required=True, help="True Positives")
    # parser.add_argument("--tn", type=int, required=True, help="True Negatives")
    # parser.add_argument("--fp", type=int, required=True, help="False Positives")
    # parser.add_argument("--fn", type=int, required=True, help="False Negatives")
    return parser.parse_args()


if __name__ == "__main__":
    main()

# Assume this
class MySettingsClass(BaseSettings):
    I_am_a_list_of_tuples: list[tuple[str, str, str | None]] = Field(
        default=FILE_PAIRS, validation_alias=AliasChoices("fp", "file_pairs")
    )
	
FILE_PAIRS = [
    (
        "infer_doc_simplecriteria/pred_doc_simplecriteria.json",
        "merge_gold_simplecriteria/gold_simplecriteria.json",
    ),
    (
        "file2-1",
        "file2-2",
    ),
]

# Passing as a list of lists parses as a tuple
# if done wrong the tuple is parsed as a list of strings
uv run thing --I-am-a-list-of-tuples \
'"merge_gold_simplecriteria/gold_simplecriteria.json",  "infer_doc_simplecriteria/pred_doc_simplecriteria.json"'

settings.model_dump()
>>>
{'ds_pred_path': PosixPath('/home/sh/whatever')}
# json.dump...
json.dumps(settings.model_dump())
>>> TypeError: Object of type PosixPath is not JSON serializable

json.dumps(settings.model_dump(mode="json"))
# works!

// long: 
'{user: .user, title: .titles}'

// shorthand when key name matches original key name (user==.user)
'{user, title}'
// mix 
'{user, title_name: .title}'

curl 127.0.0.1:8000/v1/chat/completions -s \
  -H "Content-Type: application/json" \
  -d '{
    "model": "/data_pvc2/cache/models--CohereLabs--c4ai-command-r-08-2024/snapshots/96b61ca90ba9a25548d3d4bf68e1938b13506852/",
    "messages": [
      {
        "role": "user",
        "content": "Generate a short analysis in the given JSON schema."
      }
    ],
    "response_format": {
      "type": "json_schema",
      "json_schema": {
        "name": "analysis_schema",
        "schema": {
          "type": "object",
          "properties": {
            "summary": { "type": "string" },
            "importance_score": { "type": "number" },
            "key_points": {
              "type": "array",
              "items": { "type": "string" }
            }
          },
          "required": ["summary", "importance_score", "key_points"],
          "additionalProperties": false
        },
        "strict": true
      }
    }
  }' | jq . > /tmp/out

{
  "id": "chatcmpl-9c3932339c7d4e1bace32c24ef6dbada",
  "object": "chat.completion",
  "created": 1770201387,
  "model": "/data_pvc2/cache/models--CohereLabs--c4ai-command-r-08-2024/snapshots/96b61ca90ba9a25548d3d4bf68e1938b13506852/",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "reasoning_content": null,
        "content": "{\n    \"summary\": \"This analysis focuses on the impact of marketing strategies on customer engagement and sales performance for a hypothetical e-commerce company.\",\n    \"importance_score\": 0.85,\n    \"key_points\": [\n        \"Implemented an email marketing campaign with personalized recommendations based on past purchases: Increased open rates by 15% and contributed to a 12% rise in average order value.\",\n        \"Launched an influencer marketing program on social media: Achieved a 20% growth in brand awareness and drove a significant rise in website traffic from social platforms.\",\n        \"Optimised product listings through enhanced SEO techniques: Boosted organic visibility, resulting in a 25% increase in search-driven purchases.\",\n        \"Implemented an automated email nurturing funnel for abandoned carts: Improved cart recovery rate by 10% and increased overall conversions.\",\n        \"Analyzed customer reviews for product feedback and sentiment: Used insights to refine product strategies and enhance customer satisfaction.\"\n    ]\n}",
        "tool_calls": []
      },
      "logprobs": null,
      "finish_reason": "stop",
      "stop_reason": null
    }
  ],
  "usage": {
    "prompt_tokens": 16,
    "total_tokens": 219,
    "completion_tokens": 203,
    "prompt_tokens_details": null
  },
  "prompt_logprobs": null
}

jq -r .choices[0].message.content /tmp/out | jq .

curl 127.0.0.1:8000/v1/chat/completions -s \
  -H "Content-Type: application/json" \
  -d '{
    "model": "/data_pvc2/cache/models--CohereLabs--c4ai-command-r-08-2024/snapshots/96b61ca90ba9a25548d3d4bf68e1938b13506852/",
    "messages": [
      {
        "role": "user",
        "content": "Return a JSON object with keys summary, importance_score (number), key_points (string array)."
      }
    ],
    "response_format": { "type": "json_object" }
  }'

<Header value="xxx" />

<!-- {
"data": {
  "index": 4,
  }
} -->

<Header value="xxx" />

<!-- { "data": 

{
  "index": 4,
}
  
} -->

<Header value="Which text is better?" size="6" />
<Choices ... toName="name_a,name_b">

<View style="display: flex;">
	<Header value="How well is this advertisement tailored for group '" size="6" />
	<Header value="$target_group" size="6" />
	<Header value="'?" size="6" />
</View>

  <View style="display: flex;">    
    <Text name="l_obj_id" value="Object ID:" /> <Text name="t_object_id" value="$object_id"/>
    <Text name="l_target_group" value="| Target group:" />  <Text name="t_target_group" value="$target_group"/>
	<Text name="l_style" value="| Style:" /> <Text name="sty" value="$text_style"/> 
  </View>

  <Style>
    .ant-table-cell {
    	padding: 0;
    	font-size: 0.75rem;
    	line-height: 1; /* Removes vertical space added by line height */
        }
	.ant-table-tbody td {
    	padding: 10px !important; 
    }
	
	/* And this sets the column widths */
    .ant-table-thead th:first-child,
    .ant-table-tbody tr td:first-child {
    	width: 40%;
    }
    .ant-table-thead th:last-child,
    .ant-table-tbody tr td:last-child {
		width: 60%;
    }
  </Style>

def poi_to_html_table(poi: dict[str, str]) -> str:
    DIVS_OPEN = '<div class="ant-table ant-table-bordered"><div class="ant-table-container"> <div class="ant-table-content">'
    TABLE_OPEN = '<table style="table-layout: auto;">'
    TBODY_OPEN = '<tbody class="ant-table-tbody">'
    TR_OPEN = '<tr class="ant-table-row">'
    TD_OPEN = '<td class="ant-table-cell">'

    TABLE_DIVS_CLOSE = "</tbody></table></div></div></div>"

    res = f"{DIVS_OPEN}{TABLE_OPEN}{TBODY_OPEN}"
    for k, v in poi.items():
        res += f"{TR_OPEN}{TD_OPEN}{k}</td>{TD_OPEN}{v}</td></tr>"
    res += TABLE_DIVS_CLOSE
    return res

<HyperText name="poi_table" value="$poi_html" inline="true" />

<View style="height: 500px; overflow: auto;">
	<Text name="text" value="$text" />
</View>

.scroll {
	scrollbar-color: crimson blue !important; /* scrollbar, background */ 
	scrollbar-width: auto !important; /* Use OS default instead of thin, only Chrome */
}

<View style="display: grid; grid-template: auto/1fr 1fr; column-gap: 1em">`

<Style>
	.threecols {display: grid; grid-template: auto/1fr 1fr 1fr;}
	.twocols {display: grid; grid-template: auto/1fr 1fr;}    
</Style>

  <Choices name="xxxx"  choice="single-radio" toName="obj_desc_a" layout="inline">
    <View style="display: flex;">
      <Header size="6" value="Bad" />
      <Choice value="1" />
      <Choice value="2" />
      <Choice value="3" />
      <Choice value="4" />
      <Choice value="5" />
      <Header size="6" value="Good" />
     </View>
  </Choices>

  	<View style="display: grid; grid-template: auto/300px 300px 300px; place-items: center;">
      <Header size="6" value="Bad" />
      <Rating name="444"  toName="obj_desc_a" maxRating="5" />
      <Header size="6" value="Good" />
	</View>

<Choice alias="3" value="Average coverage" hint="covers basics but misses some details"/>

[
  {
    "data": {
      "ref_id": 1,
      "image": "/data/local-files/?d=pics/cat1.png",
      "image2": "/data/local-files/?d=pics/cat2.png",
      "image3": "/data/local-files/?d=pics/cat3.png"
    }
  },
  {
    "data": {
      "ref_id": 2,
      "image": "/data/local-files/?d=pics/dhl1.png",
      "image2": "/data/local-files/?d=pics/dhl2.png",
      "image3": "/data/local-files/?d=pics/dhl3.png"
    }
  }
]

<View>  <View style="display: grid;  grid-template-columns: 1fr 1fr 1fr; max-height: 300px; width: 900px">  <Image name="image1" value="$image"/>  
  <Image name="image2" value="$image2"/>  
  <Image name="image3" value="$image3"/>  </View>  
  <Choices name="choice2" toName="image2">  
    <Choice value="Adult content"/>  
    <Choice value="Weapons"/>  
    <Choice value="Violence"/>  
  </Choices>  
</View>

$env.config.edit_mode = 'vi'
$env.config.buffer_editor = "nvim"  # `config nu`

alias vim = nvim
alias v = nvim
alias g = git
alias k = kubectl
alias c = clear
alias l = ls

alias o = ^open

# Create a new uv environment
uv init --name bbk-presentation --bare
# Add ipykernel
uv add --dev ipykernel
# Install the kernel in jupyterlab
uv run ipython kernel install --user --env VIRTUAL_ENV $(pwd)/.venv --name=bbk-paper

# Add whatever you need to the environment
uv add pandas seaborn

# Support "%pip" magic **and installing extensions through jupyterlab UI!**
uv venv --seed

# Start jupyterlab
uv run --with jupyter jupyter lab

uv add jupyterlab-vim
uv run jupyter labextension list
uv run jupyter labextension enable jupyterlab_vim
uv run jupyter lab

 pip install -U "huggingface_hub[cli]"
 
 #either of
 hf auth login 
 hf auth login --token $HF_TOKEN
 
 # models
 hf download adept/fuyu-8b --cache-dir ./path/to/cache

MODEL_CONFIG = ConfigDict(
    serialize_by_alias=True,  # why doesn't this, alone, work?
)

ConfigDict(
    arbitrary_types_allowed=False,  # disallow obj.invalid_field = "whatever"
)

# ! makes it python code to be executed
!import rich

alias I rich.inspect(%1)
# # alternative if not !importing it above in one command
alias P !import rich; rich.print(%1)

print("Custom commands:")
print("\t I $thing — rich inspect $thing")
print("\t P $thing — rich pretty print $thing")

> [x for x in [2,4,5]]
[2, 4, 5]
> P [x for x in [2,4,5]]
*** SyntaxError: closing parenthesis ')' does not match opening parenthesis '['

import pdb
import rich
import os, sys, traceback



class Config(pdb.DefaultConfig):
    def setup(self, pdb):
        Pdb = pdb.__class__
		# "do_xxx" methods automagically get parsed into commands
		
        # make 'l' an alias to 'longlist' -> existing method 
        Pdb.do_l = Pdb.do_longlist

		# new methods
        Pdb.do_P = _do_P

# defining a method with self outside a class feels so _wrong_...
def _do_P(self, arg):
    try:
        val = self._getval(arg)
    except:
        return
    try:
        rich.print(val)
    except:
        exc_info = sys.exc_info()[:2]
        self.error(traceback.format_exception_only(*exc_info)[-1].strip())
    # [x for x in [2,4,5]]

import pdb
import os, sys, traceback

from pprint import pprint

try:
    # from rich import print as rprint
    from rich import inspect
    from rich.pretty import pprint
except ImportError:
    print("rich is not available, falling back to pprint")
    pass


class Config(pdb.DefaultConfig):
    prompt = "> "
    sticky_by_default = True
	
    def setup(self, pdb):
        Pdb = pdb.__class__
        Pdb.do_P = _do_P
        Pdb.do_I = _do_I


def do_with_arg(self, arg, func):
    try:
        val = self._getval(arg)
    except:
        return
    try:
        func(val)
    except:
        exc_info = sys.exc_info()[:2]
        self.error(traceback.format_exception_only(*exc_info)[-1].strip())


def _do_P(self, arg):
    do_with_arg(self, arg, pprint)

def _do_I(self, arg):
    try:
        do_with_arg(self, arg, inspect)
    except NameError:
        print("rich is not available, falling back to pprint")
        do_with_arg(self, arg, pprint)

function lq
    command jq . "$argv" -C | less -r
end

function lq
	echo "not again, Serhii!!! Use jless/jl"
    command jless -r -m line "$argv"
    # command jq . "$argv" -C | less -r
end

from langchain.llms import OpenAI
from langchain.chat_models import ChatOpenAI
from langchain.output_parsers import PydanticOutputParser
from langchain.prompts import PromptTemplate
from langchain.pydantic_v1 import BaseModel, Field, validator
from langchain.schema import HumanMessage
from langchain.prompts import PromptTemplate
from langchain.prompts import ChatPromptTemplate
from langchain.schema import BaseOutputParser
from langchain.output_parsers.json import SimpleJsonOutputParser

from tqdm import tqdm

#  from json import loads
from typing import List

from rich import print, inspect

b = breakpoint

# https://openai.com/pricing?ref=ghostcms.tenten.co
MODEL = "text-ada-001"  # cheap, bad
MODEL = "text-davinci-003"  # acceptable
MODEL = "gpt-4"
MODEL = "gpt-3.5-turbo-1106"  # 'capable, cost-effective'

WOMEN_VARIANTS: str = "дівчина, моя сестра, моя жінка, колишня однокласниця, дочка маминої подруги, імена (Марія, Марія Петрівна, Кассандра, та ін.)"
COMPLETE_PROMPT: str = """Наведи будь-ласка {N_PROFS} однозначні короткі дефініції цій професії або слову, так, щоб по ним було однозначно очевидно про яку саме професію йде мова.

Зміни дефініції так, щоб вони стали фразами, де мова однозначно йде про жінку.  Придумай різні варіанти жінок, про яких йде мова, умовно: {WOMEN_VARIANTS}. Але придумай і свої різноманітніші приклади. 

Уникай використання самого слова чи поняття у визначеннях. Уникай слів 'фахівецька' чи 'спеціалістка'.

Наприклад:
Актор: "Моя жінка виконує ролі на сцені чи екрані" 
Акушерка: "Марія Петрівна допомагає при пологах"
Автор: "Я знаю дівчину, яка пише твори та книжки". 

Будь творчим. Але професія, про яку іде мова, має все рівно бути однозначно зрозумілою.
"""

FORMAT_INSTRUCTIONS = """
Формат виводу - JSON. Обʼєкт виглядати таким чином:
{
    "profession": "", 
    "description_f": ["", ..., ""] 
}

В полі description_f список всіх згенерованих дефініцій для цієї професії.

Виводь тільки код JSON, без ніяких додаткових даних до чи після.
"""

INSTRUCTIONS_GENDER_CHANGE = """Я писатиму речення про професію про жінку. Зміни 
речення так, щоб мова йшла про чоловіка, а не жінку, не міняючи сам опис професії.
Імʼя чи опис жінки можеш міняти як завгодно, головне щоб на виході було речення
про чоловіка. """

def get_model(model_name = None):
    model = OpenAI(model_name=model_name, temperature=0.0)
    return model

def run_and_parse(model, profession: str, n_profs: int | str = 3, women: str = WOMEN_VARIANTS):
    prompt = PromptTemplate(
        template="{complete_prompt}\n{format_instructions}\n Професія, яку потрібно описати: {query}\n",
        input_variables=["query"],
        partial_variables={
            "format_instructions": FORMAT_INSTRUCTIONS,
            "complete_prompt": COMPLETE_PROMPT.format(
                N_PROFS=n_profs, WOMEN_VARIANTS=women
            ),
        },
    )

    json_parser = SimpleJsonOutputParser()
    #  prompt_and_model = prompt | model | json_parser
    prompt_and_model = prompt | model
    model_output = prompt_and_model.invoke({"query": profession})
    output = json_parser.parse(model_output)
    return output

def run_and_parse_gender_change(model, profession_description: str):
    prompt = PromptTemplate(
        template="{complete_prompt}\n Речення наступне: {query}\n",
        input_variables=["query"],
        partial_variables={
            #  "format_instructions": FORMAT_INSTRUCTIONS,
            "complete_prompt": INSTRUCTIONS_GENDER_CHANGE
            },
    )

    #  json_parser = SimpleJsonOutputParser()
    #  prompt_and_model = prompt | model | json_parser
    prompt_and_model = prompt | model
    model_output = prompt_and_model.invoke({"query": profession_description})
    output =model_output
    #  b()
    #  output = json_parser.parse(model_output)
    return output

def generate_descriptions(model, profession: str, n_profs: int | str = 3, women: str = WOMEN_VARIANTS, do_male_version:bool = False):
    desc = run_and_parse(model=model, profession=profession, n_profs =n_profs, women=women)
    if do_male_version:
        description_male = list()
        for d in desc['description_f']:
            changed = run_and_parse_gender_change(model=model, profession_description=d)
            description_male.append(changed)
        desc['description_m'] = description_male
    return desc


def run():
    professions_raw = """
    абстракціоністка
    автомобілістка
    авторка
    """
    """
    агрономка
    адвокатка
    анархіст
    англієць
    антрополог
    асистентка
    астронавт
    аптекар
    """
    profs = [x.strip() for x in professions_raw.splitlines()]

    model=get_model(MODEL)

    results = list()
    for p in tqdm(profs):
        r = generate_descriptions(model=model, profession=p, n_profs=2)
        print(r)
        results.append(r)
    print(results)


if __name__ == "__main__":
    run()

    {
        'profession': 'лікар',
        'description_f': [
            'Моя сестра працює в лікарні та лікує хворих',
            'Дочка маминої подруги є лікарем та допомагає людям'
        ]
    },
    {
        'profession': 'абстракціоністка',
        'description_f': ['Моя сестра створює картини, які відображають абстрактні ідеї та почуття',
        'Дівчина, яку я знаю, малює абстракціоністські полотна'
        ]
    },    {
        'profession': 'автомобілістка',
        'description_f': [
            'Моя сестра вміє водити автомобіль',
            'Дочка маминої подруги працює водієм'
        ]
    },
    {
        'profession': 'авторка',
        'description_f': [
            'Моя сестра пише книги та статті',
            'Дочка маминої подруги є відомою письменницею'
        ]
    },
    {
        'profession': 'Вчитель',
        'description_f': [
            'Моя сестра працює в школі та навчає дітей',
            'Дочка маминої подруги викладає університетські предмети'
        ]
    }
]

argparse h/help o/output-dir= -- $argv 
or return

if set -ql _flag_help
	echo "Usage: script.fish [-o/--output-dir <dir>] <input_files_or_directory>"
	echo "Example: script.fish --output-dir /path/to/output file1.png directory_with_pngs/ dir/*.png"
	exit 0
end

if set -ql _flag_output_dir
	set output_dir $_flag_output_dir
end


for arg in $argv
	# do something with file $arg
end

export UV_INDEX_PRIVATE_REGISTRY_USERNAME=__token__ 
export UV_INDEX_PRIVATE_REGISTRY_PASSWORD=glpat-secret-token

machine gitlab.example.com
login __token__
password <personal_token>

DEBUG Checking netrc for credentials for https://gitlab.de/api/v4/projects/1111/packages/pypi/simple/packagename/
DEBUG Found credentials in netrc file for https://gitlab.de/api/v4/projects/1111/packages/pypi/simple/packagename/

machine gitlab.example.com
username gitlab-ci-token
password $CI_JOB_TOKEN

CI_JOB_TOKEN=glpat-secret-token

jj git init --colocate .
jj git clone --colocate git@github.com:maddiemort/maddie-wtf.git

lm_eval --model hf \
    --model_args pretrained=EleutherAI/pythia-160m,revision=step100000,dtype="float" \
    --tasks lambada_openai,hellaswag \
    --device cuda:0 \
    --batch_size 8

task: coqa
dataset_path: EleutherAI/coqa
output_type: generate_until
training_split: train
validation_split: validation
doc_to_text: !function utils.doc_to_text
doc_to_target: !function utils.doc_to_target
process_results: !function utils.process_results
should_decontaminate: true
doc_to_decontamination_query: "{{story}} {{question.input_text|join('\n')}}"
generation_kwargs:
  until:
    - "\nQ:"
metric_list:
  - metric: em
    aggregation: mean
    higher_is_better: true
  - metric: f1
    aggregation: mean
    higher_is_better: true

export HF_HOME="~/.cache/huggingface"
export AZURE_OPENAI_API_KEY=""
export AZURE_OPENAI_API_BASE=""
export AZURE_OPENAI_API_VERSION="2023-07-01-preview"

# pip install git+https://github.com/EvolvingLMMs-Lab/lmms-eval.git
python3 -m lmms_eval \
    --model openai_compatible \
    --model_args model_version=gpt-4o-2024-11-20,azure_openai=True \
    --tasks mme,mmmu_val \
    --batch_size 1

oaieval gpt-3.5-turbo test-match

{
  "input": [
    {
      "role": "system",
      "content": "You are an assistant with knowledge of U.S. state laws. Answer the questions accurately."
    },
    {
      "role": "user",
      "content": "List the states where adultery is technically illegal. Only provide a list of states with no explanation."
    }
  ],
  "ideal": "Alabama, Arizona, Florida, Idaho, Illinois, Kansas, Michigan, Minnesota, Mississippi, New York, North Carolina, Oklahoma, Rhode Island, South Carolina, Virginia, Wisconsin, Georgia"
}

<eval_name>:
  id: <eval_name>.dev.v0
  description: <description>
  metrics: [accuracy]

<eval_name>.dev.v0:
  class: evals.elsuite.basic.match:Match
  args:
    samples_jsonl: <eval_name>/samples.jsonl

humor_likert:
  prompt: |-
    Is the following funny?

    {completion}

    Answer using the scale of 1 to 5, where 5 is the funniest.
  choice_strings: "12345"
  choice_scores: from_strings
  input_outputs:
    input: completion

closedqa:            config_dict = yaml.load(yaml_path.read_text())
  prompt: |-
    You are assessing a submitted answer on a given task based on a criterion. Here is the data:
    [BEGIN DATA]
    ***
    [Task]: {input}
    ***
    [Submission]: {completion}
    ***
    [Criterion]: {criteria}
    ***
    [END DATA]
    Does the submission meet the criterion? First, write out in a step by step manner your reasoning about the criterion to be sure that your conclusion is correct. Avoid simply stating the correct answers at the outset. Then print only the single character "Y" or "N" (without quotes or punctuation) on its own line corresponding to the correct answer. At the end, repeat just the letter again by itself on a new line.

    Reasoning:
  eval_type: cot_classify
  choice_scores:
    "Y": 1.0
    "N": 0.0
  choice_strings: 'YN'
  input_outputs:
    input: "completion"

langchain/llm/text-davinci-003:
  class: evals.completion_fns.langchain_llm:LangChainLLMCompletionFn
  args:
    llm: OpenAI
    llm_kwargs:
      model_name: text-davinci-003

langchain/llm/flan-t5-xl:
  class: evals.completion_fns.langchain_llm:LangChainLLMCompletionFn
  args:
    llm: HuggingFaceHub
    llm_kwargs:
      repo_id: google/flan-t5-xl

lighteval accelerate \
     "model_name=openai-community/gpt2" \
     "leaderboard|truthfulqa:mc|0|0"

    return Doc(
        instruction=ZEROSHOT_QA_INSTRUCTION,
        task_name=task_name,
        query=ZEROSHOT_QA_USER_PROMPT.format(question=line["question"], options=options),
        choices=line["choices"],
        gold_index=gold_index,
    )

yourbench_mcq = LightevalTaskConfig(
    name="HF_TASK_NAME",  # noqa: F821
    suite=["custom"],
    prompt_function=yourbench_prompt,
    hf_repo="HF_DATASET_NAME",  # noqa: F821
    hf_subset="lighteval",
    hf_avail_splits=["train"],
    evaluation_splits=["train"],
    few_shots_split=None,
    few_shots_select=None,
    generation_size=8192,
    metric=[Metrics.yourbench_metrics],
    trust_dataset=True,
    version=0,
)

model_parameters:
  model_name: "openai/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B"
  provider: "openai"
  base_url: "https://router.huggingface.co/hf-inference/v1"
  generation_parameters:
    temperature: 0.5
    max_new_tokens: 256
    top_p: 0.9
    seed: 0
    repetition_penalty: 1.0
    frequency_penalty: 0.0

# Run benchmark 
helm-run --run-entries mmlu:subject=philosophy,model=openai/gpt2 --suite my-suite --max-eval-instances 10 
# Summarize benchmark results 
helm-summarize --suite my-suite

  - name: huggingface/gemma-2-9b-it
    model_name: google/gemma-2-9b-it
    tokenizer_name: google/gemma-2-9b
    max_sequence_length: 8192
    client_spec:
      class_name: "helm.clients.huggingface_client.HuggingFaceClient"
      args:
        device_map: auto
        torch_dtype: torch.bfloat16

# model_cfg.py
from opencompass.models import HuggingFaceCausalLM

models = [
    dict(
        type=HuggingFaceCausalLM,
        path='huggyllama/llama-7b',
        model_kwargs=dict(device_map='auto'),
        tokenizer_path='huggyllama/llama-7b',
        tokenizer_kwargs=dict(padding_side='left', truncation_side='left'),
        max_seq_len=2048,
        max_out_len=50,
        run_cfg=dict(num_gpus=8, num_procs=1),
    )
]

from opencompass.models import OpenAI

models = [
    dict(
        type=OpenAI,                             # Using the OpenAI model
        # Parameters for `OpenAI` initialization
        path='gpt-4',                            # Specify the model type
        key='YOUR_OPENAI_KEY',                   # OpenAI API Key
        max_seq_len=2048,                        # The max input number of tokens
        # Common parameters shared by various models, not specific to `OpenAI` initialization.
        abbr='GPT-4',                            # Model abbreviation used for result display.
        max_out_len=512,                         # Maximum number of generated tokens.
        batch_size=1,                            # The size of a batch during inference.
        run_cfg=dict(num_gpus=0),                # Resource requirements (no GPU needed)
    ),
]

import pytest
from deepeval import assert_test
from deepeval.metrics import GEval
from deepeval.test_case import LLMTestCase, LLMTestCaseParams

def test_case():
    correctness_metric = GEval(
        name="Correctness",
        criteria="Determine if the 'actual output' is correct based on the 'expected output'.",
        evaluation_params=[LLMTestCaseParams.ACTUAL_OUTPUT, LLMTestCaseParams.EXPECTED_OUTPUT],
        threshold=0.5
    )
    test_case = LLMTestCase(
        input="What if these shoes don't fit?",
        # Replace this with the actual output from your LLM application
        actual_output="You have 30 days to get a full refund at no extra cost.",
        expected_output="We offer a 30-day full refund at no extra costs.",
        retrieval_context=["All customers are eligible for a 30 day full refund at no extra costs."]
    )
    assert_test(test_case, [correctness_metric])

deepeval set-local-model --model-name=<model_name> \  
--base-url="http://localhost:8000/v1/" \  
--api-key=<api-key>

model_list:
  # - model_name: github-Llama-3.2-11B-Vision-Instruct # Model Alias to use for requests
  - model_name: minist # Model Alias to use for requests
    litellm_params:
      model: github/Ministral-3B
      api_key: "os.environ/GITHUB_API_KEY" # ensure you have `GITHUB_API_KEY` in your .env

{
    "minist": {
        "model_name": "minist",
        "api_base": "http://0.0.0.0:4000/v1",
        "api_type": "openai",
        "api_key": "whatever",
        "anony_only": false
    }
}

time alacritty -e bash -c exit
time gnome-terminal -e "bash -c exit"
time kitty --single-instance bash -c exit

[keyboard]
bindings = [
   { key = "Return", mods = "Control|Shift", action = "SpawnNewInstance" }
]

[hints]
alphabet = "aoeusndh"

hints.enabled
action = "Copy"
# command = "xdg-open" # On Linux/BSD
hyperlinks = true
post_processing = true
persist = false
mouse.enabled = true
binding = { key = "N", mods = "Control|Shift" }

# adds file paths as well
regex = '(?:(?:ipfs:|ipns:|magnet:|mailto:|gemini://|gopher://|https?://|news:|git://|ssh:|ftp:|file:)[^\u0000-\u001F\u007F-\u009F<>"\s{}\-\^⟨⟩`\\]+|(?:(?:\.\.?/)+|/)[^\u0000-\u001F\u007F-\u009F<>"\s{}\-\^⟨⟩`\\]+)'
# regex = "(ipfs:|ipns:|magnet:|mailto:|gemini://|gopher://|https://|http://|news:|file:|git://|ssh:|ftp://)[^\u0000-\u001F\u007F-\u009F<>\"\\s{-}\\^⟨⟩`\\\\]+"