semvec/pypi-packages huggingface dataset:
zcs-azzurro-api 2023.3.2
Unofficial ZCS Azzurro client for Python

![ZCS Azzurro API image](https://github.com/AlePerla/zcs_azzurro_api/blob/main/icon.png?raw=true "ZCS Azzurro API logo")
# ZCS Azzurro client for Python
The unofficial python client for ZCS Azzurro API.

# Instructions
Access rights and credentials has to be asked to ZCS Azzurro support. 
The maintainer of this package does not manage access, 
which is in total control of the ZCS Azzurro APIs developers.

# Disclaimer
This package is not managed by the developer of the APIs and comes with no warranty about the functioning or the timing.
It is not guaranteed also the full implementation of all the functions of the APIs itself.
The package could be discontinued at any time and it might be outdated with the APIs, 
though it will be updated as much as possible.
You can use it under license conditions and under your responsibility.

Keep this on going >
<a href="https://paypal.me/aleperla13" target="_blank"><img src="https://www.paypalobjects.com/webstatic/mktg/logo/pp_cc_mark_37x23.jpg" border="0" alt="PayPal Logo" style="height: auto !important;width: auto !important;">Support</a>
tkinterdnd2-osxarm64 0.1.0
TkinterDnD2 is a python wrapper for George Petasis'' tkDnD Tk extension version 2
Requires Python: >=3.6

## fork

this is fork of [tkinterdnd2](https://github.com/pmgagne/tkinterdnd2) which is a python wrapper for [tkdnd](https://github.com/petasis/tkdnd)
.

This fork replaced macOS x86_64 dylib with arm64 dylib. if want to use tkinterdnd2 on intel mac, please use original repo, or my edited universal repo via
`pip install tkinterdnd2-universal` for compatibility on both x64 and arm64 Mac machine

this repo forked and edited to be published to pypi so one could simply install this package
with  `pip install tkinterdnd2-osxarm64`.

## install

`python -m pip install tkinterdnd2-osxarm64`

## usage

```python
import tkinter as tk

from tkinterdnd2 import DND_FILES, TkinterDnD

root = TkinterDnD.Tk()  # notice - use this instead of tk.Tk()

lb = tk.Listbox(root)
lb.insert(1, "drag files to here")

# register the listbox as a drop target
lb.drop_target_register(DND_FILES)
lb.dnd_bind('<<Drop>>', lambda e: lb.insert(tk.END, e.data))

lb.pack()
root.mainloop()
```
![tkinterdnd2 example usage](https://i.stack.imgur.com/jnOWd.png)


see any of the [demos](./demos) for usage examples.

# tkinterdnd2

Tkinter native drag and drop support for windows, unix and Mac OSX.

## What is TkInterDnD2

[TkinterDnD2](http://tkinterdnd.sourceforge.net) is a python wrapper for George Petasis' tkDnD Tk extension version 2.

It is a domain public project.

## What is TkDnD2

[tkDnD2](https://github.com/petasis/tkdnd) is a tcl/Tk extension adding native drag and drop support.

## What this repository is about

It package TkinterDnD2 and tkdnd2 into a standard python module.

When the extension is imported in python its location will be automatically added to the Tk search path.

In this project we use the pre-compiled release
from https://github.com/petasis/tkdnd/releases/tag/tkdnd-release-test-v2.9.2 and copy them in tkinterdnd2/tkdnd.

## pyinstaller

If you want to use pyinstaller, you should use the hook-tkinterdnd2.py file included. Copy it in the base directory of
your project, then:

    pyinstaller -F -w myproject/myproject.py --additional-hooks-dir=.
jupyter_aichat 0.0.3
Jupyter magic command for having AI chat conversations in a notebook

================
 jupyter-aichat
================

.. image:: https://mybinder.org/badge_logo.svg
 :target: https://mybinder.org/v2/gh/akaihola/jupyter-aichat/main?labpath=example.ipynb

::

    !pip install jupyter-aichat

::

    Collecting jupyter_aichat
      Downloading jupyter_aichat-0.0.1-py2.py3-none-any.whl (3.9 kB)
    Installing collected packages: jupyter_aichat
    Successfully installed jupyter_aichat-0.0.1

::

    %load_ext jupyter_aichat

::

    %%ai
    I've created an AI chat user interface for Jupyter notebooks.
    It adds the `%ai` and `%%ai` magic commands for writing messages,
    renders response messages in the notebook,
    and keeps the whole conversation in memory.

That sounds really interesting! Can you tell me more about how it works and what kind
of AI it uses?

::

    %%ai
    The user just types `%ai "<message>"` or `%%ai` followed by a multi-line message.
    It asks for the ChatGPT API key before sending the first message.
    Both sent messages and received messages are kept in memory
    and the whole message history is submitted every time the magic command is used.
    The response from ChatGPT is rendered as Markdown.

That sounds really convenient! And what exactly is ChatGPT and how does it generate
responses?

::

    %ai "I think you know that best yourself :)"

As an AI language model, I don't know everything about what specific tools or
algorithms you've used in the creation of your AI chat user interface. However,
generally speaking, GPT (Generative Pre-trained Transformer) is a type of language
model that uses deep learning to generate human-like text. ChatGPT is a variant of GPT
specifically designed for chatbots and conversational agents, and it has been trained
on vast amounts of existing human conversations to learn how to simulate natural
language interactions. When a user inputs a message, ChatGPT uses this training to
generate an appropriate response based on the context of the conversation.

::

    %%ai
    Thanks for the summary!
    I'm publishing this on GitHub and putting this very discussion as the README.

That sounds like a great idea! Having a clear explanation of how the chat interface
works and the technology it uses will help make it more accessible to potential users.
Good luck with your project!
proscan-log-api 1.2.5
Log API for PSI's PROSCAN
Requires Python: >=3.8,<4.0

# log_API - PROSCAN LOG API

#### Table of Contents
- [Introduction](#introduction)
- [Installation](#installation)
- [Quick-start Guid](#quick-start-guide)
- [Documentation](#documentation)
- [Dependencies](#dependencies)
- [Contribute](#contribute)
- [Project Changes and Tagged Releases](#project-changes-and-tagged-releases)
- [Developer Notes](#developer-notes)
- [Contact](#contact)

# Introduction
This project/package aims to provide a simple way to get PASS, TDS and TCS Logs.

# Installation
Install with pip
```bash
pip install proscan_log_api
```
# Quick-start Guide
Here are some simple examples to get you started:
```python


```


# Documentation
Current Features:


Check out the wiki for more info!

# Dependencies
None!


# Contribute
To contribute, simply clone the project.
You can uses ``` pip -r requirements.txt ``` or the Makefile to set up the project.
After that you can make changes and create a pull request or if allowed merge your changes.


# Project Changes and Tagged Releases
* See the Changelog file for further information
* Project releases are available in pypi

# Developer Notes
Currently None

# Contact
If you have any questions pleas contract 'niklas.laufkoetter@psi.ch'
viper-df 0.0.7
Simple, expressive pipeline syntax to transform and manipulate data with ease
Requires Python: >=3.8

# viper

<a href='https://aropele.github.io/viper/'><img src='docs/logo.png' align="right" width="150" /></a>

[![PyPI version](https://badge.fury.io/py/viper-df.svg)](https://pypi.org/project/viper-df/)
[![pages-build](https://github.com/aropele/viper/actions/workflows/pages/pages-build-deployment/badge.svg?branch=gh-pages)](https://github.com/aropele/viper/actions/workflows/pages/pages-build-deployment)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

> Simple, expressive pipeline syntax to transform and manipulate data with ease 

## Overview

`viper` is a Python package that provides a simple, expressive way to work with data. It allows you to easily manipulate and transform data using a pipeline syntax similar to that of [dplyr](https://dplyr.tidyverse.org/).
 
Pipelining your DataFrame manipulation operations offers several benefits:

- improved code readability (no need to 'comment the what')
- no need to save intermediate dataframes
- ability to chain a long sequence of operations in a single command
- thinking of coding as a series of transformations between the input and the desired output can improve the design and make it less coupled

## Docs
Complete documentation and reference are available on the package's [site](https://aropele.github.io/viper/).

## Quick Start

Installation:
``` shell
pip install viper-df
```

Here is an example of how to use `viper` to analyze the famed `mtcars` dataset.

We want to find:
- the average consumption, expressed in Miles/(US) gallon
- the average power

Furthermore:
- only consider those cars that weigh more than 2000lbs
- group the results by the number of cylinders and number of gears
- arrange in descending orders by the grouping variables


``` python
import viper as v
from viper.data import mtcars

v.pipeline(
    mtcars,
    v.rename(
        "hp = power",
        "mpg = consumption",
    ),
    v.mutate(
        consumption=lambda r: 1 / r["consumption"]
    ),
    v.filter(
        lambda r: r["wt"] > 2
    ),
    v.group_by("cyl", "gear"),
    v.summarize(
        "power = mean()",
        "consumption = mean()"
    ),
    v.arrange(
        "cyl desc",
        "gear desc"
    ),
)
#                power  consumption
# cyl gear
# 8   5     299.500000     0.064979
#     3     194.166667     0.068824
# 6   5     175.000000     0.050761
#     4     116.500000     0.050875
#     3     107.500000     0.050989
# 4   5      91.000000     0.038462
#     4      85.000000     0.041259
#     3      97.000000     0.046512
```

[Here](https://aropele.github.io/viper/usage/) you can find more examples, particularly on joins.

## Roadmap

The future development of the package will probably focus on:

- adding `pivot_longer`and `pivot_wider` functions
- adding more `join_*` functions

## Contributions

You are welcome to contribute to the project or open [issues](https://github.com/aropele/viper/issues) if you have any ideas.