Have you ever experienced that moment, when you try to phonecall a number, and you have a small mistake in one of the digits? That's exactly what happens when you import the wrong package into your code! Unintended answers will be received from the other side. In this talk, we will discover a unique attack vector that hackers exploit to have direct access to your repository, and how to avoid it.

# What is it about?
Dependency confusion is a new attack vector that was discovered in early 2021 by the security researcher Alex Birsan, where he discovered that multiple big organizations such as Microsoft, Apple, and others, are vulnerable to this sort of software supply chain exploit.
The actual vulnerability resides in the fact that the developer makes a mistake in importing one or more of the packages to the source code, in that case, if an attacker has disclosure to the used packages, can search through package indexes (e.g. PyPI) and use that mistake in his favor, upload a malware to the index, which will be later imported to the affected piece of code.

# What's the impact?
An attacker will have direct read and write permissions in the code, even worse, can perform other malicious activities, such as dumping the database, deleting files, disclosing sensitive information, and more...

# Small example
Suppose in a big project, a developer made a small typo and instead of importing the "requests" library he imported "reqests". Suppose also that this "reqests" library is just imported but not used, so the developer won't get any errors after running his code. If the attacker somehow can know about that, he will go to PyPI, and search for [reqests](https://pypi.org/search/?q=reqests), he will find that there's no previously created package with that name, so he will create one on the index, that contains some malicious code, such as a reverse shell or just a simple fetcher that will help him dump everything from the backend of the infected project.

# Outline of the talk
In my talk, I will try to explain in simple terms what dependency confusion is, followed by some real-world examples of previously found vulnerabilities, in all different package indexes. This is going it be sort of a security awareness presentation so that developers should pay more attention to what they're including in their code from the internet. I will try to follow this schedule:
- Introduction (5 minutes)
- Who am I? (5 minutes)
- Wrong phone number example (3 minutes)
- Code snippets examples based on the previous example (7 minutes)
- Real-world scenarios of the vulnerability (5 minutes)
- Best practices and ways to avoid (5 minutes)

Please keep in mind this schedule is subject to change, but the skeleton is going to be the same.

Khalil A. Lemtaffah

Dodging Dependency Confusion In A Nutshell

Generators in Python can be found in many kinds of projects and applications. But how do they work exactly and how are they implemented?

In this talk, we will try to better understand generators in Python. We'll start from the beginning with iterators and make our way up to generators and how they're being used in applications today. To further cement our understanding, we'll look at how generators are implemented in Python's most popular reference implementation, CPython.

Steph Samson

Internals of Generators

Is your relationship with maths... complicated?

Do you hate doing simple, repetitive, error prone calculations that you know your computer could easily do?

Have you ever been disappointed by Wolfram Alpha's inability to calculate your problems, with working out?

Then book a session and I’ll show you how to use Python, SymPy, & SageMath to resolve your love problems, all with working out!

If you hate doing simple, repetitive, error prone calculations that you know a computer could trivially do, then this is the talk for you!

You'll learn the basics of SymPy and the SageMath libraries, and then be walked through how to solve a sample university level maths problem. Then, we'll put these two together and use SymPy to solve this math problem for us, and in a way that also prints working out!

You'll also see how Jupyter can be used to calculate and submit parts of your assignment, and finally how you can help contribute to the computational maths community.

Evan Kohilas

Python ate my homework!

本セッションでは、Python 3.11の新機能、Data Class Transforms（PEP 681）について解説します。
PEP 681でtypingモジュールに追加されたdataclass_transformデコレーターは、これまでattrs、Pydantic、O/Rマッパー（例: SQLAlchemy、Django内臓のO/Rマッパー）などのライブラリでの型チェックが十分に効かなかった問題を解決し、より堅牢なコードを実現します。
デコレーターの内部メカニズムも掘り下げ、さらに主要な型チェッカーのPEP 681への対応状況、そして対応ライブラリの紹介も行います。
型安全を確保しつつ、より強力なデータ操作を実現するPythonの新機能を、ぜひ本セッションで学びましょう。

## クラスの初期化処理で型チェックが効かない問題の解説
まず最初に、PEP 681登場以前のPythonにどのような問題があったのかを解説します。

PEP 681の恩恵を受けるのは、[attrs](https://www.attrs.org/en/stable/)、[Pydantic](https://docs.pydantic.dev/latest/)、O/Rマッパー（例: [SQLAlchemy](https://www.sqlalchemy.org/)、[Django](https://docs.djangoproject.com/ja//)内臓のO/Rマッパー）などのデータクラス風にクラスを書けるライブラリですが、今回は内部のコードをシンプルにしたオリジナルのO/Rマッパーを用意して説明します。

## 型チェックを強化するtyping.dataclass_transformデコレーターの使い方について解説
次に、PEP 681でtypingモジュールに追加されたdataclass_transformデコレーターの使い方について解説します。
前述のサンプルコードをdataclass_transformデコレーターを使ったものに変更することで、型チェックが効かない問題を解決できます。

本トークにより、サードパーティライブラリの選定の際に、より適切な判断ができるようになります。
また、自作のライブラリを開発されている方は、dataclass_transformデコレーターの使い方を知ることで型チェックを強化できます。

## typing.dataclass_transformデコレーター内部の仕組みについて解説
dataclass_transformデコレーター内部のソースコードについて解説します。dataclass_transformデコレーターのソースコードはとてもシンプルですが、それでも型チェッカーが高度な型チェックをできる理由を説明します。

## 主要型チェッカーのPEP 681対応状況
主要な型チェッカーでの対応状況を説明します。PEP 681は型チェッカーが対応していないと意味がない機能です。型チェッカーを採用する際、この内容を参考に選定することをお勧めします。

## PEP 681に対応しているライブラリの紹介
[attrs](https://www.attrs.org/en/stable/)、[Pydantic](https://docs.pydantic.dev/latest/)、O/Rマッパー（例: [SQLAlchemy](https://www.sqlalchemy.org/)、[Django](https://docs.djangoproject.com/ja//)内臓のO/Rマッパー）などのライブラリでのPEP 681への対応状況を紹介します。
ライブラリの採用を検討する際の判断材料にしてください。

Ryuji Tsutsui

型チェックを強化するPython 3.11の新機能Data Class Transforms（PEP 681）（Enhancing Type Checking with Python 3.11's New Feature: Data Class Transforms (PEP 681)）

旅行がしやすくなったので、地域のB級グルメを食べ歩くためのマップ作る方法を考えていきます。

このトーク では、地域のB級グルメの情報を取得して、マップを作り活用する方法を解説します。
トークの例に私が住んでいる静岡県の「富士宮やきそば」（ほかにもあるかも）を使って実際にマップを作り旅行中に利用できるものを作ります。

トークの流れは以下の通りです。

* ご当地グルメの情報はどこにあるか
    * 地域の観光情報を探す
    * そこの情報は機械可読性があるのかを考える
* 情報を収集する
    * Webスクレイピングで収集する
    * 画像識別で加工を試みる
* マップを作る
    * 地理情報を集める
    * 情報を整理する
* 旅行中に使うためのツール
    * ポータブルに扱う: 印刷をする
    * 巨人に乗る: Googleマイマップを使おう
    * 専用のWEBアプリを作ろう
* まとめ: みんなでご当地グルメマップを作ろう！

利用する技術と関連するサードパーティライブラリ、APIは以下になります。

* WEBスクレイピング: Selenium
* 画像識別: Google Cloud Vision
* WEBサービス: flet

Hiroshi Sano

ご当地グルメマップを作ろう。

日本企業はすでにデジタル化の道を進んでおり、社内には有用なデータが蓄積されています。次はこれらを社会の動きと結びつけ、効率化と価値を創造する段階です。本トークでは、ここでPythonが役立つことを示します。
社会の動きを示すデータはすでにオープンデータとして整備されています。その中にはビジネスに使いやすいデータセットもあります。Pythonの充実したエコシステムを活用すれば、これらのデータを簡単に分析し、企業価値の創出を始めることができます。Colab、Panel、plotly、pandasなどを駆使して、Pythonの分析エコシステムの強みを最大限に生かし、企業価値向上につなげることを提案します。
具体的には、ビジネスに活用しやすいデータセットの紹介と、実際に気象データ・地下鉄の乗車数・仮想売上データをPythonで分析し、企業価値を向上させる方法の提案を行います。

企業がデジタル化を進める中で、社内データの利用は一般化してきました。次のステップは、これらのデータを社会の動きと組み合わせることです。ここで重要となるのが、オープンデータの活用です。しかし、ビジネスに使いやすいオープンデータは限られています。そこで役立ちそうなオープンデータの紹介と、Pythonのエコシステムを用いてどのようにしてオープンデータを企業価値創造につなげるか、その方法と技術を提案します。

Pythonの使い方：
このプレゼンテーションでは、Pythonのエコシステムの様々なツールを使用します。

Google Colab: Pythonのコードをブラウザ上で書き、実行できるクラウドベースのJupyterノートブック環境です。Colabを使ってデータ分析のワークフローを共有し、視覚化します。

Panel: データの可視化とインタラクティブな探索を可能にする高レベルのパッケージで、ダッシュボードやアプリを作成します。Panelを使って動的なデータ可視化を作成し、分析結果を視覚的に表現します。

Plotly: 高度なインタラクティブなデータ可視化を可能にするライブラリです。Plotlyを用いて、データの特徴やパターンを視覚的に明確にします。

Pandas: データの前処理と探索的データ分析のためのツールです。Pandasを用いてデータのクリーニング、変換、集約を行います。

これらのツールを組み合わせて使用することで、データの前処理から可視化、分析、予測までの一連のデータサイエンスのワークフローを実現します。具体的な使用方法とコード例を紹介することで、オーディエンスがこれらのツールを自身のデータ分析タスクにどのように適用できるかを理解するのを助けます。

オーディエンスに伝えたいこと：
Pythonが企業のデジタルトランスフォーメーションを推進する強力なツールであることを理解してもらいたい。また、Pythonを用いて社内データと社会の動きを示すオープンデータを組み合わせることで、新たなビジネスインサイトを生み出し、企業価値を創造する可能性を示します。

タイムテーブル（15分）：

イントロダクション (2分)
デジタルトランスフォーメーションとPythonの役割について簡単に説明

データとPythonのエコシステム (3分)
日本企業のデジタル化とその中での社内データの重要性
企業価値の向上に使えるオープンデータの紹介
Pythonのエコシステム（Colab、Panel、plotly、pandas、sklearn）とその活用方法について概説

実例紹介と分析 (6分)
実際の気象データ、地下鉄のデータ、仮想売上データを用いた分析の紹介
これらのデータをPythonのエコシステムを用いてどのように分析し、価値を引き出すかを実演

コロナ禍の影響の観察と考察 (3分)
上記のデータに見られるコロナ禍の影響についての考察

まとめ（1分）
トーク内容をまとめる

hideyuki ogawa

Digital TransformationをPythonを使って進めよう！

Discover the power of learning Python by contributing to open-source projects. Gain practical experience, collaborate with the community, and enhance your coding skills. Unlock the potential of Python while making a positive impact in the world of open source.

This session explores the educational value of Python by engaging in open-source contributions. Discover how actively participating in open-source projects enhances learning, collaboration, and coding skills. Attendees will gain insights into the educational benefits of contributing to the Python community while making a tangible impact on real-world projects. Explore the synergistic relationship between Python, open source, and education, and empower yourself to become a proficient Python programmer through hands-on involvement in the open-source ecosystem.

Ananya Nayak

Learn Python by contributing to open source

新しい技術情報が毎日のように出現する昨今、これらの情報を追いかけることは時間や体力を消耗します。しかし自然言語処理の活用により、この問題を解決できます。インターネットから情報を自動収集し、その情報を分類、必要に応じて翻訳します。そしてその結果を質問応答モデルに入力することで、自分の関心に合った情報を抽出することができます。これらの機能は全てオープンソースのPythonライブラリを利用することで実現可能です。

私自身もChatGPTや日本語NLPに関する情報を自動収集し、その結果をAwesomeリポジトリとして作成し、GitHub上で公開しています。そこでユーザーからの意見を参考にした情報の効率的な整理や掲載方法をTipsとして共有します。このトークに参加することで「自動的に情報が集まるAwesomeリポジトリの作り方」を学び、さらに自然言語処理に関する知識も身につけることができます。

新しい技術情報が毎日のように出現する昨今、これらの情報を追いかけることは時間や体力を消耗します。しかし、自然言語処理を活用することで、この問題は解決することができます。

インターネットから情報を自動的に収集し、その情報を分類したり、英語から日本語への翻訳を行い、さらに検索システムと質問応答モデルを利用することで、自分の関心に合った情報を抽出することができます。これらの機能は全て、オープンソースのPythonライブラリを利用することで実現できます。さらに、それだけでは精度が不十分な場合、OpenAIのAPIを用いて改善した事例を共有します。


私自身、[ChatGPT](https://github.com/taishi-i/awesome-ChatGPT-repositories)や[日本語に関連する自然言語処理の情報](https://github.com/taishi-i/awesome-japanese-nlp-resources)を自動収集することで、情報収集にかかる時間を削減しています。また、その情報をGitHub上で公開し、オープンソースのAwesomeリポジトリ（※）を作成しています。

この経験をもとに、ユーザーにとって価値のある情報をどのように抽出するか、その情報をどのように整理し公開するかについても共有します。具体的には、既存のAwesomeリポジトリにはなかった機能（多言語化戦略、統計情報の掲載、情報公開の自動化）を開発したことで、ユーザーの評判が良かった事例を紹介します。

このトークに参加することで「必要とする情報が自動的に集まるAwesomeリポジトリの作り方」を学び、「ChatGPT時代における、Pythonライブラリを用いた自然言語処理の必要性や活用方法」について理解することができます。

※ Awesomeリポジトリ：GitHub上に公開される特定のトピックに対するリソースや参照リンクを集約したリストのこと。


【タイムライン】

・導入（3分）
 - 自己紹介
 - 本トークの概要と目的説明
 - 本トークを通じて得られるスキルと知識

・情報収集の現状（5分）
 - 情報過多による開発パフォーマンスへの影響
 - 効率的な情報収集の利点
 - 自然言語処理による情報収集の効率化
 - GitHub APIを活用した情報収集事例の紹介

・自然言語処理による情報収集の効率化（12分）
- 具体的な問題設定の説明
- Hugging Faceライブラリによるテキスト分類
- 必要な情報を抽出するためのアノテーション方法
- Pythonライブラリを用いた英語から日本語への翻訳方法
- OpenAI APIの活用方法 - Few-shot learningによるアノテーション効率化と翻訳精度の改善
- 検索システムと質問応答モデルによる情報検索

・Awesomeリポジトリの作り方（8分）
- Awesomeリポジトリの説明
- ChatGPTと日本語NLPに関するAwesomeリポジトリの紹介
- 既存のAwesomeリポジトリにない機能紹介 - 多言語化、統計情報の掲載、情報公開の自動化
- ユーザーに価値のある情報の抽出方法
- 効果的な情報の整理掲載方法
- 持続可能な情報掲載のための作業自動化方法

・まとめ（2分）
- ChatGPT時代における、Pythonライブラリを用いた自然言語処理の必要性や活用方法

池田 大志

情報収集を効率化する自然言語処理の活用方法 - PythonではじめるAwesomeリポジトリの作り方

Pythonを使ってプログラミングを学び、いろいろなものを作る方が増えています。
機械学習、Webプログラミング、組み込み分野などPythonの対応範囲は広く、多くのユーザーに受け入れられ、広まっていきました。

一方、チームで開発する際のPythonの活用・書き方についてはまだまだ課題があるように思います。
実際の業務では多くのメンバーと開発する関係から、一人で書いているとき以上に気をつけなければいけないポイントがありますが、残念ながらそのテクニックは浸透していません。
本セッションではホビープログラミングからPythonを始め、業務で多くの開発経験をするにつれ見つけてきたプラクティスや、アンチパターンについて紹介し、更に他の動的型付け言語にも共通するであろうトピックにも広げてお話します。
対象聴衆はPython及び動的型付け言語の開発の経験が浅い方です。

本セッションでは筆者が実際に失敗してきた経験や、世間でのPythonに対する評価、課題点の整理から始めます。
世間ではPythonをスクリプトやインタラクティブな実行環境の身で実行しており、そのようなユーザーがチーム開発に入っていくことは屋やハードルが高いと考えています。
筆者はこの問題について、国内外問わず、初学者のユーザーが対面する問題であると考えています。

また筆者は8年ほどPythonを書いていますが、ホビープログラミングないし個人で開発していたときと、チームで開発しているときで意識しなければいけない書き方が多く存在すると感じています。
本発表はPython経験が薄かったり、個人での開発経験しかない方に対してチームで開発する知識や情報を聴衆に持って帰っていただくことを目的としています。


発表概要は下記を予定しています。

- Python学習者を取り巻く環境(5分)
  - 様々な開発環境
  - 個人で作れるものの世界
  - 独習で陥りがちな落とし穴
- チーム開発と個人開発(15分)
  - 書くべきでない言語的な罠
    - 破壊的な動き
    - Pythonは同じように書くのが難しいのでは…？
  - 動的型付け言語全体に言える課題
    - 型情報をなるべく入れよう
    - テストコードを書こう
    - Linter, Formatterを入れよう
  - CIでもチェックする
  - コードレビューをしよう
- なぜ我々はチームでPythonを書くのか(5分)
  - 多くの人が触れる強みと弱み
  - 動的型付け言語の楽さとスピード
- まとめ(2分)
- 質疑応答(5分)

Motoki Hirao

業務で使える一歩進んだPython使いになるために

The amount of memory typically used can range from a minimum of 4G to a maximum of 64G or more. Some enterprises use even more memory than this, but in most cases, the amount of memory that can handle large volumes is limited by cost.
Let's explore different ways to approach the problem of processing large amounts of data in a constrained environment at the lowest cost using Python.

To maximize data handling within a 16GB memory constraint using Python while minimizing costs, consider the following strategies:

* Sampling data and removing unused data: Working with representative data samples and discarding unnecessary data.

* Chunks and iterators: Processing data in smaller chunks and utilizing iterators to work incrementally.

* Memory-efficient data structures: Choosing data structures optimized for memory usage, such as numpy arrays or pandas dataframes.

* Using the data compression parquet format: Compressing data using the parquet format to reduce memory footprint.

* Parallelization: Leveraging parallel processing techniques to distribute the computational load across multiple cores or machines.

* Using databases: Employing database systems like SQLite or PostgreSQL to store and query large datasets efficiently.

* Distributed processing frameworks Dask, Spark, etc.: Utilizing frameworks like Dask or Spark for distributed processing and handling large-scale data.

Each approach has its own advantages and disadvantages in terms of performance, complexity, and setup. Learn how to choose a strategy that fits your specific use case, data characteristics, and available resources to make the most efficient use of limited memory while keeping costs low.

Joeun Park

How much data can we cram into 16G RAM with less budget?

In today's fast-paced academic environment, students often are overwhelmed and disengaged because of huge workloads and lengthy-uninspiring lectures. Join me as I share my journey as a student in overcoming these challenges through fun projects/scripts and participating in the PythonPH Community.  By sharing my experiences, I aim to help students make school life easier, more exciting, and FUN.

I will talk about how Python, and activities and communities related to it,  affected my school life adventures and made them More Easier, more Exciting, and Fun. 

Specifically, I will talk about the following:
- The different Fun Python Projects I made during my undergrad. One of them was during Valentine's when I made a valentines card generator that utilizes machine learning to create unique abstract paintings out of people’s faces during Valentine's for every person. It was a random project I came up with as a joke since I spend more time coding than finding my own valentines. It was an enjoyable project that made me love coding and making projects. Sharing this experience will give everyone a good perspective on my struggles with conceptualizing a project just for the fun of it and having the motivation to work on it continuously! Detailing my experience here will be helpful to all beginners in Python!

- The different automation scripts and packages in Python made life much easier during undergrad. They were Python scripts for automating sending emails, automating certificate generation for events, cleaning class records, and using Django for creating fast, quick scalable websites for class assignments that would have taken much longer for other languages and packages. I aim to give a perspective throughout this section on how Python can make simple and easy scripts that automate the “boring and tedious” work that comes with school life.

- And lastly, how the Python Philippines Community made my after-class sessions much more fun! Having a common space with like-minded individuals who love automation, and talking about nerd topics and random projects made my school life much more fun. I will go into detail on how much of an impact the Python PH community in my creativity, motivation, and overall skillsets. This section of my talk will be helpful in everyone’s journey regardless of their proficiency in Python!

Carl John Viñas

Making School Less Boring with Python!

The students' quest to develop their Python expertise through a capstone project is the subject of this lecture. Learners first had to overcome the difficulties of coding with few tools and little to no programming knowledge. The teachers created lessons and instructed students in the fundamentals of Python to help manage these issues. Their abilities were improved as a result of this task.

The necessity to upgrade students' learning so they can cope with this rapidly changing environment served as the catalyst for this course of action. One of the newest trends is to teach students programming. Based on the suggestion of the programming consultant that we sought out, Python is a great start for beginners, which is why it has been offered in the school since 2021.

Moving forward, the following events took place:

•	The programming teacher divided the class into 10 groups.

•	The capstone project was assigned to the Grade 9 students in the second week of April.

•	Using their basic programming skills, learners are tasked with creating functional Python-based applications, websites, and edutainment games.

•	The projects were presented on May 25–26, 2023, and were reviewed by both the teachers and the judges.

•	It is very evident that each group has exerted much effort in crafting their projects, from envisioning to executing, coding to troubleshooting, producing written papers about their work, and presenting it to the judges.

•	The outputs of the learners exceeded the expectations of the teachers and the judges.


Astonished questions like the following started to surface during the capstone exhibition:
1.	How come these students were able to do such projects using their basic programming skills?
2.	What techniques they have used in creating their output?

The actual codes of the students were not included in their PowerPoint presentation. These are just the slides that they showed during the capstone exhibition.

Jericka C. Quinto

Reymann Kristian F. Zubieta

Showcasing Students' Python Programming Skills in Capstone Projects

Python へ入門したあとに苦戦するポイントの1つに、ModuleNotFoundErrorとの遭遇があります。
何が起きているのか、何がいけないのか、全体像がわからず困惑した...そんなご経験はないでしょうか?

このトークでは、Pythonのimportの仕組みをはじめとして、モジュールや名前空間、スコープに関する基礎的な知識を提供します。
これにより、参加者が自身のコーディングに際してModuleNotFoundErrorに対処できるようになることを目指します。
Pythonのimportの仕組みを把握することで、プログラムとモジュールの相互作用を理解し、Pythonの言語仕様を知るきっかけとなることを期待します。

本トークで予定している目次は以下のとおりです。

1. PythonのモジュールとModuleNotFoundError
    - モジュールとは何か
    - Pythonはモジュールをどのように扱うのか
    - ModuleNotFoundErrorとは何か、出現に至るシナリオ
2. Import・名前空間・スコープ
    - importステートメント
    - 名前空間
    - スコープ
3. import で何が起きているのか
    - モジュールの検索順序
    - ビルトインモジュール
    - sys.module
    - sys.path
4. ModuleNotFoundErrorの傾向と対策
    - ModuleNotFoundErrorのよくある原因
    - 具体的なエラー例
    - 解決までのケーススタディ
5. まとめ:
    - トークの振り返り
    - 公式ドキュメントの紹介

Toshifumi Tsutsumi

ModuleNotFoundErrorの傾向と対策:仕組みから学ぶImport

Webアプリケーション開発で何気なく使っているO/Rマッパーやデータベースアダプタのライブラリはとても便利です。
数々のライブラリが、我々がプログラムとネットワークはどのように繋がっているのかを考える必要なくデータベースと繋がることを助けてくれています。
このトークでは、ソケット通信でつながる方法を深掘りしていく他、複数のライブラリでの実現方法、PEP249で決められているルール、非同期処理をどのように実現しているか、最新のO/Rマッパーやデータベースアダプタのライブラリ事情などを紹介していきます。

Shintaro Matsudo

Pythonはどのようにデータベースと繋がるのか

Pythonのブームからかなりの年月が経ち、色々なプロジェクトのコードもどんどん負の遺産が貯まっていて来ていると思います。
そんななか、10年近く動いていたモバイルサービスのバックエンドとして使われてきたDjangoRestFrameworkの寿命を延ばすためにやった施策や取り入れたリファクタリング手法について説明していきたいと思います。

私が関わった 10年近く稼働しているDjangoのプロジェクトを改修するために行ったことについて話したいと思います。
このプロジェクトではPython2系の頃からDjangoが使われてきてPython3へのアップデートやDjangoも3系へアップデートしていくなど長く使えているシステムとなっています。
しかし、かなりレガシーな箇所や意図不明な箇所も多く、そんなレガシーコードの一貫性を保ちながら徐々に改善をしてさらに使えるシステムとして改修をしていった話をしようと思います。

### ①Fat Controller問題
DjangoRestFrameworkでもAPIViewをメインに使っていたため、すべてのビジネスロジックがviewに書かれてしまうと言う欠点がありました。
それに対して行った解決策として Service層を導入した話をしようと思います。

### ②swagger
モバイルエンジニアとのやりとりはswaggerで行っていましたが、すべて手動で行っていたため、実体と全く合っていないという問題が発生していました。
そのため、自動でswaggerを生成する仕組みの導入しました

### ③requestのチェック
またswaggerに合わせてrequest bodyやクエリ文字列のチェックのためのSerializerを導入したことも話したいと思います。

### ④コードの一貫性を保ちながら変えていくこと
既存の(やや微妙な)コードとの一貫性を保ちながら徐々にリファクタリングを入れつつ新規の処理では可読性とコメントを意識しつつ直して行ったという経緯の話もしたいと思います

### ⑤テストについて
コードの寿命を延ばすためのテストコードで意識したこと、テスト全体の問題点と改善したこと(テストケースが多すぎてciで恐ろしい時間がかかる、subtestの導入、日本語テストケースの導入など)

### ⑥その他細かいtips
上記には当てはまらない細かい改善(テストの速度改善、pre-commitやblack、poetryの導入など)について述べていこうと思います。

YUUKI NAKAJIMA

DjangoRestFrameworkのリファクタリング、レガシーなコードの寿命を延ばすために

「テストは不安を退屈に変える賢者の石だ」（ケント・ベック『テスト駆動開発』）

これはその通りで私はテストコードが書けるようになったことで、大きくPythonの力がついたと感じています。
過去の私はテストが書けず、自分の書いたコードを変更するたびに「どこか壊しているんじゃないか」という不安に苛まれ、「壊れていませんように」と祈ってきました。
それがテストコードがあると、祈る必要がなくなるのです！

自転車に乗れるようになるのと同様で、誰しも最初はテストコードを思うようには書けません。
このトークをきっかけにテストを practice, practice, practice!!!

今年のPyCon JPは「Python 初心者」がキーワードの1つのように思います。  
Python初心者に対して、初心者時代の私に一番オススメしたい知見「テストを書こう」を共有します。

初心者時代の私はPythonの関数やクラスを後から変更しやすく書くことができませんでした（今でも少し前のコードをみると伸びしろしかないなと感じます）。  
めちゃめちゃ達人のように思える開発者（冒頭で引いたケント・ベック）でも、一発で要件に合致する変更しやすいコードは書けないようです。  
なので、一発で書くという幻想は捨てて、ちょっとずつ修正していくというアプローチに切り替えました。
  
ここで有用なのがテストコードです。 
テストコードがない場合、変更した後は手動で振る舞いが変わっていないか確認しないといけません。  
何度も手動で確認するのは大変ですが、テストコードがこれを解決してくれます。  
実体験から、振る舞いを変えずに既存のコードを変えていく（例：新しく知った文法知識を練習してみる）ことで、Pythonの力が伸びると思います。

このトークをきっかけにテストを書けるようになり、Pythonの力がぐんぐん伸びて、ライブラリを公開してみようと挑戦される方がいらっしゃったらこんなにうれしいことはありません。

以下が構成です。

- 自己紹介 1分
- なぜテストコードが書けるといいのか 3分
- doctest 7分
  - 基本的な使い方
  - tips: reprの一致
- unittest 9分
  - pytestと同じ内容をunittestで紹介します
- pytest 9分
  - 基本的な使い方
  - parametrized test
  - モック
- まとめ1分

nikkie

好きとか嫌いとかはいい、練習してテストを書けるようになるんだ

Streamlit, a web-based pure-Python data app framework, has been ported to WebAssembly as "stlite".
See its power and convenience with many live examples and explore its internals from technical perspective.
You will learn how to quickly build interactive in-browser apps that work offline, maintain data privacy, and can even be packaged as desktop executables using only Python.

[Streamlit](https://streamlit.io/) is a popular framework for interactive web-based data apps in Python. However, there are some cases where users want to run their apps offline or without sending sensitive data to remote servers. To address these concerns, we introduce '[stlite](https://github.com/whitphx/stlite)': a WebAssembly port of Streamlit. It provides offline capability, data privacy, scalability, and multi-platform portability including desktop app packaging, while preserving Streamlit's original features, such as Python productivity and its rich ecosystem.

In this talk, we will discuss the benefits of stlite and demonstrate how to build and deploy stlite applications in a variety of ways, using ML/CV examples.
We will also look at its internals from a technical point of view, which may inspire you with ideas on how to make use of Pyodide and how to transform Python frameworks for the Pyodide/Wasm runtime.

You can try out stlite online: https://edit.share.stlite.net/

Yuichiro Tachibana

Streamlit meets WebAssembly - stlite

マイクロサービスをはじめとする多数のコンポーネントで動作するシステムが一般的となるなか、システムの状況を素早く理解するための仕組みとしてオブザーバビリティが注目されています。
本セッションでは、まずアプリケーションになぜオブザーバビリティが必要か、その重要性を紹介します。
次にOpenTelemetryを使ってPython製アプリケーションでオブザーバビリティを確保する方法について紹介し、実際にどのように問題が解決できるかを解説します。ここでOpenTelemetryのPythonならではの機能についても紹介します。
最後に、Python製サービスを開発運用する際に、オブザーバビリティによって得られたテレメトリーを活かして、開発者と運用担当者が、どのように開発運用プロセスを改善できるかを解説します。

本セッションはPythonアプリケーション開発者が、システムのオブザーバビリティを確保するために必要なことの概要と、それに必要な手続きを理解する上で、出発点となるセッションとなっています。すでに取り組んでいる開発者の方にとっても、理解を整理する良いきっかけとなることを期待しています。

本セッションは次のような構成を考えています。
* オブザーバビリティとはなにか
  * 定義について
* テレメトリーの種類について
  * アプリケーション開発者の作業（計装）について
* OpenTelemetryの紹介
  * プロジェクト概要
  * Pythonでの利用方法
  * Pythonならではの自動計装
* サービスレベル目標について
  * 定義
  * 活用方法

本セッションを終える頃には、システムにオブザーバビリティが必要であること、そしてそのためにはアプリケーション開発者の協力が不可欠であること、そしてひいてはそれがアプリケーション開発の速度を早め、システムのユーザーに対する信頼性を高めることに繋がることが理解されると思います。

山口能迪

Pythonアプリケーションのオブザーバビリティ強化

Using Pytest's features like assertion, fixtures, and parametrized test cases as inspiration, we will build a testing library from scratch in this talk. 

By the end of this talk, you will have a solid understanding of reverse engineering and building a testing library from scratch.

Testing is a crucial part of software development that ensures the quality and reliability of code. While many testing libraries are available, building your own library can be a valuable exercise that can deepen your understanding of testing principles and improve your testing skills.

This talk will explore how to build a testing library from scratch. 

1. Introduction to Pytest and its features - 5 mins
2. Building Test runners  - 5 mins
3. Building a parametrized test case handler - 8 mins
4. Building a fixture handler - 8 mins
5. End note - 5 mins

By the end of this talk, you will have a solid understanding of reverse engineering and building a testing library from scratch.

Bhavani Ravi

How to build a unit testing library from scratch?

Whether your task is data entry or playing a video game, Python has the power to automate it. In this talk we'll explore the power of intuitive Python libraries for I/O, then use them to automatically beat an in-browser video game using the same strategies and inputs as a human. We’ll also discuss applying project management skills to take personal projects from ideas to successes.

Even though many beginner programmers are motivated by solving day-to-day problems, many tutorials are disconnected from the real world. Automation is easy when inputs and outputs are consistent and locally stored, but how do you handle situations where that’s not the case? Using Python to automate beating a browser game is a great example of a real-world problem that’s uniquely hard to solve without Python libraries. The steps for solving this problem as a human map one-to-one with the steps for solving it programmatically and each step gives a simple and useful example of key automation libraries. Beyond highlighting some automation examples, I'll also talk about factors that led to this project's success rather than staying an eternal work-in-progress.

Jon Gaul

Automating Victory: Beating browser games with accessible Python

環境の分離や、環境構築の自動化はここ数年で「当たり前」とされるようになりました。pipenv、poetry、hatchなど、これまでPythonのパッケージ管理ツールは標準であるvenvでの仮想化をベースにして開発されてきました。一方で、いろいろなツールが登場し、求められる知識も増えてきたため、難易度が高くなってきている気がします。

Dev Containersは1つの解となりうるものですが、この中で既存のツールをそのまま適用すると2重に仮想化を重ねた環境になってしまい、初心者には難しい環境になってしまいます。また、事実上のVSCode専用となってしまいます。

Pythonistaは古来よりも、標準化と、シンプル、多様な環境での互換性を重んじてきました。この発表では、さまざまな環境を考慮した最小限のミニマルなパッケージ管理方法について検討していきます。

* Dev Containersの仕組み

    まずはDev Containersの動きや仕組みを見ていきます。Dev Containersは今までDockerや仮想PCで環境を作る時に大変だったことをいろいろ自動化してくれますし、環境のカスタマイズも簡単です。

    *  Dev Containersがやってくれること、やってくれないこと

        ユーザー、権限、同期が遅くならないファイルシステムの構成、開発サーバーのポート解放、ssh/gitのアクセス、社内のプロキシの突破方法などを紹介していきます。

    * Python用のイメージ作成方法

        ここでは、Python固有の環境をゼロから作る方法を紹介していきます。ゼロからといってもメニューから選ぶだけで簡単です。カスタマイズ方法なども紹介していきます。

* パッケージ管理ツールの動作

    ベースのDev Containersができあがったところで、さまざまなツールのインストールの動作の比較を通じて、既存のツールがDev Containersとコンフリクトしがちなポイントをまとめます。

* pyproject.tomlを書く

    pyproject.tomlはPoetryで有名になりましたが、実はPEPでルール化されている標準的なデータフォーマットです。またこのファイルを使ったパッケージのインストールには外部ツールは不要です。pyproject.tomlをダイレクトに使ったミニマルなパッケージ管理の手法を探ります。

    環境をうまく作ることでコード保管やリアルタイムのチェックをしながらファイルの編集が行えるため、それを紹介していきます。

  * できあがったPython開発環境のレビュー

    Dev Containersを使った場合、使わなかった場合のそれぞれでうまくいくことを確認していきます。

Yoshiki Shibukawa

Dev Containers時代のPython開発環境のあり方

Python 3.12 comes with an exciting new feature -- sub-interpreters. Sub-interpreters are a new programming model for Python that enable parallel execution of your code, without needing separate processes. In this talk, you will learn about sub-interpreters, how and where to use them.

Sub-Interpreters are a new feature in Python 3.12, scheduled for release in October/November 2023. Sub-Interpreters each have their own Global Interpreter Lock (GIL) meaning that you can execute code in parallel on multiple CPU cores without using multiple processes. In this talk, we will explore what parallel computation is, why it (was) hard in Python and how sub-interpreters solve that problem. We will show 3 working applications using sub-interpreters.

Anthony Shaw

Parallel code with Python 3.12 sub-interpreters

Being a slow interpreter, Python may drive a system to deliver utmost speed if some guidelines are followed. The key is to treat programming languages as syntactic sugar to the machine code. It expedites the workflow of timing, iterative design, automatic testing, optimization, and realize an HPC system balancing the time to market and quality of code. I will share how to make it happen.

Speed is the king. 10x productive developers change business. So does 10x faster code. Python is 100x slower than C++ but it only matters when you really use Python to implement number-crunching algorithms. We should not do that, and instead go directly with C++ for speed. It calls for strict disciplines of software engineering and code quality, but it should be noted that here the quality is defined by the runtime and the time to market.

The talk will focus on the Python side of the development workflow. It is made possible by confining C++ in architecture defined by the Python code, which realizes most of the software engineering. The room for writing fast C++ code is provided by pybind11 and careful design of typed data objects. The data objects hold memory buffers exposed to Python as numpy ndarrays for direct access for speed.

In a nutshell, the workflow is:

1. Understand your problem.
2. Prototype with quick and dirty Python code.
3. Define data objects. The data objects will be the API between high-level Python and the low-level C++ implementation.
4. Complete unit testing as much as possible.
5. Design data structures. Reorganize or rewrite the Python code in C++.

For each new request the workflow repeats itself.

In addition to the workflow, the talk will also include the way to use pybind11 and ndarray interface. C++ will be mentioned but outside the scope of discussions.

The objective of the talk is to show how to get started with writing fast code in Python and keep improving it to become a product. Computational scientists and engineers are particularly suitable to the subject. The talk will clearly describe a course to develop the practical coding skills. The speaker has practiced the workflow for academic research, commercial software development, and graduate-level teaching and trained more than 100 students.

Yung-Yu Chen

Write Python for Speed

Today, there are so many options for Python package management tools, such as pip (with venv), poetry, pipenv, ....

I'll compare those tools for people wondering which to use for package management tools in 2023.

This talk will be for people wondering which to use for package management tools, including library or framework developers, web developers, and automation script developers.

## Background of this talk

I wrote and posted an article in January 2023 (written in Japanese; the translated title is "Why don't you use just pip with venv for Python package management?")
I received more likes and felt surprised and happy. There might also be a demand for a sequel-like article.


## Target Audiences

I will this talk for those wondering which package management tools to use.

Especially:

- Library or framework developers
- Web Developers
- Automation Script developers

## Motivation and Objectives

Which of the following is the best option? [poetry](https://python-poetry.org/), [pipenv](https://pipenv.pypa.io/en/latest/), [pdm](https://pdm.fming.dev/latest/), [hatch](https://hatch.pypa.io/latest/) [pip-tools](https://github.com/jazzband/pip-tools), or just venv and pip? What is the best Python package and dependency management tool today?

The environment around these tools is changing dramatically; the adoption of several PEPs, including PEP [621](https://peps.python.org/pep-0621/), [517](https://peps.python.org/pep-0517/), and [660](https://peps.python.org/pep-0660/).

I will compare pros / cons and propose three use cases; based on several years of experience following Python package specifications.

### Topics not covered

* Each detail of the PEPs
* Specifications and implementations of these tools

## Planned Outline

1. Self-introduction, Table of Contents
2. Introduction:
    1. Background, Motivations
    2. Target Audiences of this Talk
    3. List of Packaging tools to compare in this Talk
3. Pros / Cons for each tools:
    1. [pip](https://pip.pypa.io/en/stable/index.html) (with venv)
    2. [pipenv](https://pipenv.pypa.io/en/latest/)
    3. [poetry](https://python-poetry.org)
    4. [pdm](https://pdm.fming.dev/latest/)
    5. [pip-tools](https://pip-tools.readthedocs.io/en/latest/)
    6. [hatch](https://hatch.pypa.io/latest/)
4. What is the best tool? (In some use cases)
    1. Case 1: Library / Framework Developing
    2. Case 2: Web Application Developing
    3. Case 3: Automation Script Developing
5. Summary
6. (Appendix) About the [rye](https://rye-up.com/)

Peacock

Comparison of Packaging Tools in 2023

This presentation explores the fascinating intersection of LIDAR technology and Python programming, shining a light on how Python empowers us to harness the full potential of LIDAR data in various applications. Dive into the world of point clouds and 3D data processing as we demonstrate how Python libraries and tools can process, manipulate, and visualize LIDAR data with ease and efficiency.

LIDAR technology, capable of producing highly accurate 3D representations of the physical world, has revolutionized a broad spectrum of industries, from autonomous vehicles and robotics to geographical mapping and archaeology. Yet, the potential of LIDAR can only be harnessed through efficient data processing and analysis methods, and this is where Python steps in.

In this talk, we will first provide a brief introduction to LIDAR and its significance in today's technological landscape. We will then delve into the vast Python ecosystem and its capabilities for handling LIDAR data, discussing key Python libraries such as PDAL (Point Data Abstraction Library), PyLidar, and others that facilitate the processing and visualization of point cloud data.

The following key points will be covered:

-Overview of LIDAR technology and its applications
-Introduction to point cloud data and its challenges
-Python tools and libraries for LIDAR data processing
-Case studies demonstrating real-world usage of Python in LIDAR data analysis
-Future trends in LIDAR data processing with Python

Attendees will walk away with a deeper understanding of the power of Python in processing complex LIDAR data, and the knowledge to utilize Python tools to kickstart their journey in the world of LIDAR technology.

Whether you're a data scientist exploring new data types, a Python enthusiast keen on learning its applications in cutting-edge technology, or an industry professional looking to leverage LIDAR data, this talk will shine a light on the path ahead. Join us as we illuminate the future with LIDAR and Python.

Phillip Andrew Espina

Unleashing the Power of LIDAR with Python

Variant, a term once only known to the researchers of biological sciences, is now familiar to the general people. Rising of the new variants of SARS-Cov2 virus with new mutations has become a concern during this COVID-19 pandemic. How do the researchers identify these variants from the analysis of genomics data? How could Python be used in this analysis? This talk will address these questions.

Variant, a term once only known to the researchers of biological sciences, is now quite familiar to the general people. Rising of the new variants of SARS-Cov2 virus with novel mutations have become a topic of concern during this COVID-19 pandemic. How do the researchers identify these variants from the analysis of genomics data? How could Python be used in this analysis? This talk will address these questions. 

Mutations in any organism are usually identified after performing a Next Generation Sequence analysis experiment named variant calling. Variant calling generates the output in a specialized file format called Variant Call Format (VCF) file. VCF file carries the meta data and the information of thousands of mutations and is generally large in size. Thus, it is challenging to extract information and identify mutations from this file, especially when there are hundreds of samples. The Python package scikit-allel provides utilities for exploring this large-scale genetic variation data in VCF file and helps to identify important mutations from the downstream analysis. This package depends on scipy, matplotlib, seaborn, pandas, scikit-learn, h5py and zarr. After identifying the mutations, the next step is the visualization of the mutations in a meaningful way. This task might be simpler for a small size virus like SARS-Cov2, but complicated for eukaryotic organisms with multiple chromosomes like mouse or human. Another python package QMplot is handy and useful for the visualization of thousands of mutations in each chromosome, making the interpretation of the extracted mutations easier for the biologists. This package uses numpy, scipy, pandas and matplotlib. 

During this talk I will show the usability of these Python packages for analyzing high throughput genetic variation data and discuss the avenues of the development of new Python packages to make this analysis more efficient. Besides informing the Python community about the application of Python in genomics research, this talk will be informative to the developers who want to work in the intersection of computer science and genomics. 
 
Outline  Intro (5 min)  
Who are we?  
Introducing the concept of mutation and variants  
Explaining the genetic variation data (VCF file)  
Why Python for Variant analysis? (10 min)  
High dimensional data  
Introducing scikit-allel  
Filtering and identification of Mutation using scikit-allel  
Visualization of mutations (10 min)  
Explaining the importance of visualization of mutation to get meaningful insight  
Introducing QMplot for mutation visualization  
Explaining example plots created on publicly available data  
Q&A (5 mins)

Haque Ishfaq

Atia Binte Amin

Using Python for Disease Variant Analysis

Let's implement objects that are useless for anything.
For example, an object whose length returned by the len() function is different every time, or an object that returns a bullshit result when you check if a value exists with the in operator.
And through the implementation, you will get a better understanding of Python data types.

本発表で実装するPythonオブジェクトはまったく役に立ちません。
しかし、まったく役に立たないオブジェクトを実装すると、Pythonのデータ型の理解が深まります。
そして、役に立つオブジェクトが実装できるようになります。

本発表で扱うテーマは2つあります。

まず、len()関数やin演算子、for文の裏側で何が起きているのかを理解することです。
例えば、オブジェクト``obj``を``len()``関数に渡した場合、``len(obj)``の結果は``obj.__len__()``を返します。
つまり、``obj.__len__()``の実装を滅茶苦茶にすれば、``len(obj)``の結果も無茶苦茶になります。
なぜ役に立たないオブジェクトが作れるのか、そして、どうすれば正しい振る舞いをするオブジェクトが実装できるのかを通して、Pythonが裏側で処理していることを理解します。

2つ目は、``collections.abc``にある抽象基底クラスの使い方を理解することです。
Pythonの組み込みコンテナとしてリスト、タプル、辞書、集合があります。
そして、組み込みコンテナは、簡単に言えば``collections.abc``にある抽象基底クラス``Sized``、``Container``、``Iterable``からなります。
役に立たないオブジェクトを実装しようとして無茶苦茶に実装しても正しく使えません。
抽象基底クラスの助けを借りることで、振る舞いは無茶苦茶なのに既存のPythonオブジェクトにも協調する役に立たないオブジェクトを作ります。
その経験を通して、抽象基底クラスの使い方や正しい自作コンテナの作り方を学ぶことができます。

基本的なアジェンダは以下の通りです。

- 前説：まったく役に立たないオブジェクトを作ろう
- 基本編：``Sized``、``Container``、``Iterable``から始めよう
  - ``ElasticSized``： 実行するたびにlen()関数の返り値が変化するオブジェクト
  - ``ForgottenContainer``： 実行するたびにin演算子の結果が変化するオブジェクト
  - ``ShuffledIterable``： ``for``文の実行結果が毎回変わるオブジェクト
- 応用編： 変わり果てたコンテナたち
  - ``UncontrolledSequence``： 無秩序なシーケンス
  - ``MisprintedDictionary`` 乱丁した辞書
  - ``CrowdSet``： 烏合の集合

The Python objects implemented in this presentation are not useful at all.
However, implementing completely useless objects will give you a better understanding of Python data types.
You will then be able to implement useful objects.

There are two topics covered in this presentation.

The first is understanding what happens behind the scenes of the len() function, the in operator, and the for statement.
For example, if you pass an object ``obj`` to the ``len()`` function, the result of ``len(obj)`` will be ``obj.__len__()``.
In other words, if you screw up the implementation of ``obj.__len__()``, the result of ``len(obj)`` will also be screwed up.
You will understand what Python does behind the scenes, why you can create useless objects, and how to implement objects that behave correctly.

Second, you will understand how to use the abstract base classes in ``collections.abc``.
Python's built-in containers include lists, tuples, dictionaries, and sets.
And the built-in containers, simply put, consist of the abstract base classes ``Sized``, ``Container`` and ``Iterable`` in ``collections.abc``.
If you try to implement a useless object and implement it in an absurd way, you will not be able to use it properly.
Using the abstract base class, you can create useless objects whose behaviour is absurd, but which also work with existing Python objects.
Through this experience, you will learn how to use abstract base classes and how to create your own containers correctly.

The basic agenda is as follows

- Preliminaries: let's create a totally useless object.
- Basics: start with ``Sized``, ``Container`` and ``Iterable``.
  - ``ElasticSized``: an object that changes the return value of the ``len()`` function each time it is executed.
  - ``ForgottenContainer``: an object where the result of the in operator changes each time it is executed.
  - ``ShuffledIterable``: An object whose ``for`` statement changes the result each time it is executed.
- Applications: Uncontrolled containers.
  - ``UncontrolledSequence``: An uncontrolled sequence.
  - ``MisprintedDictionary``: A misprinted dictionary.
  - ``CrowdSet``: A crowd set

Hayao Suzuki

Let's implement useless Python objects

The Python community is amazing! They bring together people who share common altruistic goals, and the magic of collaboration and innovation flourishes. However, despite the abundance of positive outcomes, community stewards often face challenges such as burnout and succession planning. So the question remains: how do we make this good thing last?

As co-founders of Python Philippines (PythonPH), we've faced numerous challenges, including the departure of team members without a succession plan, having to take additional workloads, and experiencing burnout. In this talk, we'll share our personal journey and offer strategies that have helped us overcome these pain points.

We understand first-hand the uncertainty and pressure that come with the loss of co-founders and how it can impact the remaining team members. Drawing from our experience, we'll share the steps we took in creating a succession plan that will ensure continuity and minimize disruption.

Furthermore, we'll discuss how we've dealt with burnout and share tips for maintaining a healthy work-life-community balance. As we've navigated these challenges, we've also faced feelings of being left behind from a shared mission. We'll offer insights on how we stay motivated and focused on achieving organizational goals, even when it feels like others have moved on.

This talk will provide attendees with a personal account of the challenges and rewards of managing a long-running organization:

1. Succession planning is crucial for long-running organizations to ensure continuity and minimize disruption when leaders and team members depart.
2. Burnout is a common challenge for long-running organizations and can have a negative impact on productivity and morale. Strategies for preventing burnout and maintaining a healthy work-life-community balance are key.
3. Feelings of being left behind from a shared mission are normal but can be overcome by staying focused on the organization's mission.
    
Managing a long-running organization comes with unique challenges, but with the right strategies and mindset, it can be incredibly rewarding and fulfilling.

Matt Lebrun

Micaela Reyes

(PythonPH) One Does Not Simply Create a Lasting Tech Community: Our 10-Year Journey Through the Joys and Challenges of Building a Fulfilling and Impactful Community

In this session, we provide a hands-on introduction to LocalStack, a fully functional local AWS cloud stack. With LocalStack, Python-based cloud applications and infrastructure can be developed entirely on your local machine, reducing dev&test cycles from minutes to seconds.

DevOps teams across the globe are increasingly focusing time and energy on optimizing their cloud development and deployment flows. The traditional deploy-and-test cycles against public clouds can become slow and tedious, where developers are often facing several minutes of idle times between deployments that need to be frequently triggered during testing & debugging.

Also, with the increasing popularity of Infrastructure-as-Code tools like Terraform or Pulumi, efficient testing of automated infrastructure deployments becomes critical. Testing cycles for deployments of complex stacks with large-scale resources can easily take 15+ minutes or more in the real cloud.

In this talk, we will provide a detailed deep dive into LocalStack, an open-source cloud emulator that allows you to develop Python cloud & serverless applications entirely on your local machine without ever having to connect to the real cloud! LocalStack provides 70+ AWS services running in a Docker container completely on your local machine. We will develop AWS applications, but since LocalStack runs entirely on the local machine without talking to the real cloud, no cloud access credentials are required to follow the talk.

The talk is roughly structured as follows:

- Intro to AWS cloud development with Python
- Getting started with LocalStack
- Developing Python serverless apps with LocalStack
- Advanced integrations for Infrastructure-as-Code (Terraform, CDK) and CI/CD (Github Actions)
- Python internals of LocalStack
- Summary and Q&A

The session covers interactive live coding to showcase common scenarios and use cases, different settings for local debugging of Lambdas and containerized apps as well as some advanced new features that can radically improve productivity and team collaboration patterns.

Harsh Bardhan Mishra

Develop your Python cloud & serverless apps locally with LocalStack!

We don’t need AI for writing better code! Formators like Black and PyBetter have been automatically refactoring messy code way before AI agents claim to help you write codes. In this talk, we are going to explore how formatters analyse and manipulate the CST of your code to make it nicer.

Recently year there are AI agents that pops up in the market saying that they can help you to write code. However, there are tools out there that have been used over decades that can help us write better codes - the auto formats like Black and PyBetter that can refactor your code into nicer-looking ones. In this talk, we are going to explore how auto-formators analyse and manipulate the CST of your code to make it nicer.

First, we will introduce what is an Abstract Syntax Tree (AST) and a Concrete Syntax Tree (CST). Next, we will talk about libcst and how it analyses the code and express the CST of your code as Python objects. Then, we explore how we can use the match method provided and modify our code if the logic matches. By the end of it, the auto-formators would not be a mystery for the audience anymore as we now understand the inner working of it.

## Outline

- Introduction: What is AST and what is CST, and what are the differences (5 mins)
- Introducing libcst: example codes (5 mins)
- Matching CST patterns: example of doing it with libcst 5 mins)
- How auto-formatter works (10 mins)
- Conclusions (5 mins)

Cheuk Ting Ho

Reformating your code without AI - let's see how a formatter work

Pythonプログラムを実行する際のメモリプロファイリングは重要です。ただ、実態を掴むのは難しいです。メモリプロファイリングの手法は大きく分けて2つ有ります。それらの特徴を知り、より実態をつかみやすいトレーシング手法を用いてているツールである [Memray](https://bloomberg.github.io/memray/) の使い方を解説します。

このトークでは、Pythonのメモリ状態の詳細をデモ画面を交えながら解説します。

リストの作り方による違いや、NumPyのメモリ確保の状況がわかります。さまざまなアウトプット方法がありますのでそれらの違いについても解説します。Jupyter Integrationも解説します。

このトークを見たら、自身のコードのメモリ状態の詳細を確認することができるようになります。

Memrayは、Python3.11のリリースマネージャーの「Pablo氏」が開発の中心にいる注目のツールです。

データ分析やシミュレーションを行う際に大きなデータを使うことがあります。その際のメモリ状態を見るのは重要です。NumPyなどのC拡張が使われているライブラリが確保するメモリの状態を見るのは難しいですが、今回紹介するMemrayはC拡張を含むPythonコードが実行されたメモリの状態を詳細にトレーシングします。
また、子プロセスを生成する `Celery` や `Gunicorn` などの状況も確認できます。

## トークの流れ

- メモリプロファイラとは
    - 必要性
    - 2つの手法を紹介
    - ツールの紹介
    - プロファイリングの難しさ
- Python用メモリプロファイラMemrayの紹介
- Memrayの基本的な使い方
    - プロファイルの実行
    - 結果の表示
    - 現状をライブで見る
- Pythonのコーディングによる違い
    - メモリの確保状況の違い
    - 実行時間の違いも見れる
- NumPyを使った確認
    - メモリ確保の可視化
    - C拡張でも状況がきちんとわかる
- 一歩進んだ使い方
    - Jupyter Integration を使う
    - with ステートメントで部分的に状態を見る
    - pytest limit でテストにメモリ制限を設ける

Manabu TERADA

メモリプロファイラMemrayのススメ

企業の活動をより良くするために、データから価値を生み続けるためにデータ活用を行うことが広く行われるようになってきました。
本公演ではPythonを使って大規模なデータパイプラインを構築していくための考慮すべき点を紹介し、より可用性の高い実行環境を構築する方法を共有します。
特にECサイトでの増え続けるデータに対してApache Airflowのマネージドサービス であるGoogle Cloudの Cloud Composerを使うと、より早く、よりロバストなワークフローが実装しやすくなることを共有します。

現代のビジネスでは、データの活用が企業活動の効率化や新たな価値創造に対する鍵と広く認識されています。データは、膨大な情報量から洞察を引き出し、戦略的意思決定を支援します。特に、ECサイトの運営にはデータ量の増加に対応するために、大規模なデータパイプラインの構築が不可欠となっています。

本公演では、商品情報の構築を題材に、検索システムのマイグレーションと、データの表示に関わる業務利用に対するデータ加工とAPIの提供を行った事例を紹介します。構築する中で、複雑なデータフローを管理し、一貫性を保つための要点を詳細に解説し、信頼性が高く効率的な実行環境の設計方法を共有します。機能要件/非機能要件がある中で着目して改善していった過程も事例を交えて共有します。

また、データパイプラインはGoogle CloudのCloud ComposerというApache Airflowのマネージドサービスを利用して構築しました。Airflowを用いてデータ処理のワークフローをより早く、よりロバストに構築する方法についても具体的に紹介します。

本公演を通じて、データ活用とその具体的な技術について深く理解し、ご自身のビジネス環境にどのように適用するかをイメージしていただけると幸いです。

* データ活用基盤とは
    * データ活用基盤の紹介
* データパイプラインの構築
    * データ活用基盤でのデータパイプラインの構築などを紹介
* Apache Airflowの紹介
* 事例紹介
    * データパイプラインを構築して改善していく方法
        * 事例を交えながら apache airflowでのデータパイプライン構築と改善の流れを紹介
    　* Google cloudのマネージドサービスCloud Composer の紹介
    * データパイプラインにて構築したデータのAPIでの公開
        * データ活用のデータをシステムで活かすためにAPIとして共有するときのノウハウを紹介
* まとめ

中村真人

Pythonのワークフローエンジン Apache Airflowを用いた大規模データパイプライン構築と改善

ハイパーパラメータ最適化フレームワークOptunaは、すでに多くの機械学習エンジニアに利用されるソフトウェアとなりました。現在も活発に開発が続いており日々多くの新機能が加わる一方で、ややニッチな領域であるためにOptunaの一般的な利用者にはまだまだ知られていない機能も多く存在します。本セッションでは、Optunaのコア開発者を務める発表者が、Optunaをより一層使いこなしていただくための最新機能やユースケースについて紹介します。

発表は以下のような流れを予定しています。

1. 自己紹介
2. 発表のアジェンダ
3. ハイパーパラメータ最適化フレームワークOptunaの紹介
    * Optunaの基本的な使い方
    * Optunaの利用事例紹介
4. Optunaの最新機能：Human-in-the-loop最適化
    * Optunaがこれまで扱うことができなかったユースケースの紹介
    * Optuna開発チームが力を入れて開発を進めている最新機能「Human-in-the-loop最適化」の紹介
    * LLMやStable Diffusionに適用するデモの紹介 (実際に動作している様子を画面共有しながらお話する予定です)
5. その他の最新機能の紹介
    * Optunaの最新リリース v3.2 やそれ以降のリリースで導入された最新機能をいくつかピックアップし紹介します。
    * なお、PyCon APACの開催までに2つのOptunaリリースが予定されているため、その時点で最新の機能を紹介させていただきたいなと思っています。そのため、ここで紹介する内容は一部未定となっています。
6. まとめ
    * 本セッションでお話したことを振り返り
    * みなさまへのお願い：OptunaおよびHuman-in-the-loop最適化を様々な問題に応用して利用事例を発信していただければ幸いです。

Masashi Shibata

ハイパーパラメータ最適化フレームワークOptunaの最新機能紹介

クロスワードパズルを自動生成するWebアプリケーションを題材に、API呼び出し・自然言語処理・組合せ探索・可視化など多様な処理を手軽に実装できるPythonの応用性の高さを報告する。アプリケーションでは、ニュース記事からクロスワードパズルの解として適切な単語とその説明を抽出する自然言語処理パートと、入力された単語から矛盾の無いクロスワードパズルを生成する探索パートを全てPythonで記述した。自然言語処理パートでは記事情報を取得するAPIを呼び出し、読み仮名付与や形態素解析などの自然言語処理ライブラリを活用する。探索パートでは、クロスワードパズルのレイアウトを設計する組合せ探索を実装した。さらに、これらの処理の可視化には、PythonのWebアプリケーションフレームワークであるStreamlitを用いている。発表では、デモを交えながらアプリケーションを紹介し、開発における知見を共有する。

本講演では、ニュース記事を入力としてヒント付きクロスワードパズルを自動生成するWebアプリケーションを紹介する。アプリケーション内ではAPIの呼び出し、自然言語処理、組合せ探索、可視化などの複数の複雑な処理が実行されるが、全てPythonで実装されている。デモを交えたアプリケーションの紹介によって、Pythonの応用可能性、実現可能な処理の多様性、手軽さについて発信する。

本アプリケーションを作成した背景として、講師が所属するニュースメディア業界におけるパズルの役割の大きさがある。特にクロスワードパズルは人気のコンテンツであり、多くのニュースメディアが掲載している。「顧客に合わせたクロスワードパズルを自動で生成できれば、より顧客の満足度を高められる」という仮説のもと、本アプリケーションを作成した。

アプリケーションは複数のニュース記事を入力として、ニュース記事内の単語を含むクロスワードパズルと各単語のヒントを自動で出力し、表示する。入力するニュース記事を、顧客が閲覧した記事、朝刊の一面の記事、特定のジャンルの記事などに限定することで、様々なコンセプトのクロスワードパズルを自動生成できる。

アプリケーションは自然言語処理パートと探索パートに分かれている。自然言語処理パートではまず、記事情報を取得するAPIを呼び出してニュース記事の文章データを取得する。APIの呼び出し、認証にはrequestsライブラリを用いている。次に、クロスワードパズルの解として適切な単語とその説明を抽出する。この処理にはre, spacy, pykakasi, jaconvなどの多くの自然言語処理ライブラリを用いている。探索パートでは、自然言語処理パートで抽出された単語に加え、wikipediaなどの外部ソースの単語も入力として、矛盾の無いクロスワードパズルを生成する。この生成には深さ優先探索の一種であるバックトラッキングをベースとしたアルゴリズムが採用されており、ニュース記事から抽出された単語を多く含むクロスワードパズルが生成される。アルゴリズムは学術論文を参考に、本アプリケーションの設定に合わせて変更したものをPythonで実装した。アプリケーション全体はPythonのWebアプリケーション作成フレームワークであるStreamlitによって実装されている。クロスワードパズルのサイズや取得するニュース記事のジャンルなどのパラメーターを簡単に変更でき、クロスワードパズルの生成過程をインタラクティブに表示できる。

開発における課題として、1. 多様な処理を実装する必要がある 2. アプリケーションの実装に割くことのできる時間が限られている という2点があった。Pythonのみでアプリケーションを実装することで、これらの課題を解決した。1点目については、Pythonの豊富なライブラリを活用して対処した。全ての処理を同一言語で記述することは、処理の集約が簡単になるというメリットもある。2点目については、Streamlitを用いることで手軽にアプリケーションを作成した。可視化までの実装期間を短くすることで、効率的にフィードバックを得て改善できた。

発表の構成は以下の通りである。導入では、発表の全体像・目的とアプリケーションを作成した背景・モチベーションについて説明した後、アプリケーションの概要をデモを交えながら紹介する。次に、アプリケーションのアーキテクチャと内部で実行されている処理について、関連するPythonライブラリを中心に解説する。そして、アプリケーション開発の開発者体験について、Pythonのみで開発した感想、振り返りを中心に紹介する。

導入（3min）
- 自己紹介
- 発表の全体像・目的
アプリケーションの概要（7min）
- デモンストレーション
- 作成した背景・モチベーション
- アプリケーションの説明
アプリケーションの詳細（12min）
- アプリケーションのアーキテクチャ
- それぞれの処理について
  - API呼び出し
  - 自然言語処理
  - 組合せ探索
- Webアプリケーションについて
開発者体験（8min）
- Pythonのみでの開発について
  - ライブラリの豊富さ
  - 手軽さ
  - コミュニケーションの取りやすさ
- 今後の展望
- まとめ

本発表のWebアプリケーションの詳細なアルゴリズム、内部処理についての論文

馬嶋海斗

Pythonだけでクロスワードパズルを自動生成 〜自然言語処理・組合せ探索・Webアプリ開発〜

コンピュータの世界はゼロとイチで成り立っています。
この文章もPythonのロゴ画像もみなさんが書いているプログラムもすべてゼロとイチで表現されています。

ということはみなさん知っているでしょう。  
しかし、そのことを意識したことがなかったり、「バイナリ」や「バイト列」という言葉に苦手意識を感じる方も多いのではないでしょうか。

本セッションでは、Pythonの対話モードやprint()、structモジュールなどを使ってバイナリの世界を覗いてみます。

バイナリに慣れるとより深くコンピュータを知ることができ、目の前の世界が一気に広がります。
本セッションを通じて、その最初の一歩を踏み出しましょう。

コンピュータの世界はゼロとイチで成り立っています。
この文章もPythonのロゴ画像もみなさんが書いているプログラムもすべてゼロとイチで表現されています。

ということはみなさん知っているでしょう。  
しかし、そのことを意識したことがなかったり、「バイナリ」や「バイト列」という言葉に苦手意識を感じる方も多いのではないでしょうか。

本セッションでは、Pythonの対話モードやprint()、structモジュールなどを使ってバイナリの世界を覗いてみます。
より具体的にはPythonで書いたソースコードやデータベースファイルなどを対象に、その見方のコツやフォーマット仕様書を理解するために必要な用語を解説します。

バイナリに慣れるとより深くコンピュータを知ることができ、目の前の世界が一気に広がります。
本セッションを通じて、その最初の一歩を踏み出しましょう。

Rei Suyama

Pythonで一歩踏み出すバイナリの世界

Streaming data processing is a type of data processing that deals wit continuously generated data and cannot be processed in its entirety. Streaming data processing is a challenging problem because it requires algorithms that can process data quickly and efficiently. In this talk, the speaker will share how to create streaming data pipelines easily by using Python libraries like Apache Beam.

Streaming data processing is a type of data processing that deals with data that is continuously generated and cannot be stored in its entirety. This type of data is often generated by sensors, machines, and other devices that collect data in real time. Streaming data processing is a challenging problem because it requires algorithms that can process data quickly and efficiently, while also being able to handle changes in the data stream.

In this talk, the speaker will start with an introduction to streaming data processing, including the different types of streaming data and the challenges of processing streaming data. After that, the speaker will discuss Python libraries for streaming data processing, such as Apache Beam, and how it helps solve the issue. The speaker will also highlight a case study of streaming data processing, such as real-time fraud detection. Finally, the session will end with answering audience questions.

After this talk, the audience will be able to:
- Understand the basics of streaming data processing
- Understand the characteristics and challenges of streaming data
- Use Python libraries for streaming data processing
- Apply streaming data processing to real-world problems

Thu Ya Kyaw

Beaming up to the flow!

In this talk, we will talk about how to reproduce the Evangelion countdown timer (活動限界まであと) on Web Browsers  using PyScript , Pyodide, SVG and CSS. Although countdown timer is trivial to implement on browsers, it can be challenging if the graphic design has to be the same as the one in Evangelion. And to make it more fun, we are going to implement this using PyScript!

We will cover:
- the appreciation of the Evangelion countdown timer design (the fonts, the colours and the design has changed over the course of time)
- how to reproduce the graphical elements using SVG 
- how to use PyScript to interact with DOM and SVG
- how to use CSS to format and animate the GUI components
- lessons learnt related to PyScript
- to good and the bad in using PyScript as oppose to Javascript
- You can(not) do this in Python!

Scotty Kwok

Reproduce Evangelion Timer on browsers using PyScript

Modern web development often involves complex processes and context-switching, impacting efficiency. This talk proposes a solution: using Django-HTMX to unify front-end and back-end development into one context. This approach simplifies the build process and minimizes context-switching. With Django-HTMX for HTMX, TailwindCSS for CSS, and Alpine.js for JavaScript, we aim to simplify and streamline

Modern web development often necessitates complex processes and context-switching, placing undue burdens on developers and impeding efficiency. This presentation proposes a solution: unifying front-end and back-end development into a single context with Django-HTMX. This approach eliminates the need for separate build processes and mitigates the slowdown associated with context-switching between different development languages. In this streamlined workflow, HTMX is employed through Django-HTMX, CSS is handled with TailwindCSS, and JavaScript is managed with Alpine.js. By introducing this efficient and simplified method, we aim to revolutionize the way web development is approached, creating a more streamlined and efficient future for developers.

Bae KwonHan

Breaking Down Barriers: A Unified Approach to Web Development with django-htmx

本セッションでは、「FinTechの現場でFastAPIがどのように使われているか」の理想と現実をお届けします。理想的な姿はあれど、業務ではさじ加減で現実的なやり方を採用することになります。そのいい塩梅をお伝えします。

2023年発売の「動かして学ぶ！Python FastAPI開発入門」では実務で使えるFastAPIのテクニックを紹介しています。本には盛り込みきれなかったこれからFastAPIを使ってみたいと思っている方や、運用を始めたばかりの方に、現場の肌感や躓きポイントを知っていただければと思います。

Sho Nakamura

FinTechの現場でバリバリ活躍するFastAPIの理想と現実

本セッションでは、パケット処理系の開発について、性能評価を通じた改善プロセスとして一緒に探求します。
はじめにパケット処理の基本原理・ベンチマーキングの手法について説明したのち、改善プロセスで中心となる 性能試験環境・結果の可視化 で Python をどのように活用したか紹介します。
この発表を通じて、自社のネットワークや自作パケット処理の性能測定と向上に関心のある開発者、エンジニア、アーキテクトにとって「通信の高速化ってこうやって行うのか！」とちょっと世界の見方が変わる有益な時間を提供します

- 背景とモチベ
    - 弊社ではフルMVNO事業をやっており、その中のPGW-Uと呼ばれるインターネットに出るための自作パケット処理系の通信効率の性能を上げることが求められていました
    - そのためにpython製のツールとライブラリを駆使して計測し高速化をしました
- 話す内容
    - 私たちは、XDPと呼ばれるeBPFを使った高速パケット処理技術を使って実装しています
    - 性能試験を通した改善プロセスでは、負荷試験のパケット生成・テスト結果の記録・メトリックの分析など多くの場面で Python を活用しています
    - それぞれの場面での活用事例を紹介します
        - scapy で TRex のパケット生成にモバイル網で使うプロトコルのパケットを追加しました
        - 性能試験のテスト完了後、性能指標を TRex から取得し Pushgateway で記録しました
        - Jupyter Lab 上で Grafana 経由の CSV ファイルを pandas.DataFrame に加工し、可視化や評価を行いました
    - 性能試験を通じた改善例
        - 大容量のエントリを流した際にメモリ使用量が大きくなるとコケる問題を発見して修正した事例
        - パケットのcheck sumの処理で遅くなったので処理性能を向上させるためにchecksum機能をoptoutする機能を追加した事例
        - 特定のパケットに対してマルチコア対応がされていないことを発見して、IntelのNICドライバに機能を追加してマルチコア対応させた。その結果$(nproc| CPUコア数)倍の効率アップができた事例

Takeru Hayasaka

自作パケット処理系の性能測定と可視化&改善のPDCAを回して最強のパケット処理系の作り方を学ぼう

Webアプリケーションの開発と運用において必要な知識は多岐に渡ります。

フレームワークの使い方を覚えることはもちろん重要ですが、開発したアプリケーションは本番システムにリリースして実際に稼働することになります。  
そして、リリースしたシステムは継続的に運用していく必要があります。

このセッションでは、本番システムでの運用を見据えたアプリケーション開発に必要な知識や勘所を紹介します。

Webアプリケーションの開発と運用において必要な知識は多岐に渡ります。

フレームワークの使い方を覚えることはもちろん重要ですが、開発したアプリケーションは本番システムにリリースして実際に稼働することになります。  
そして、リリースしたシステムは継続的に運用していく必要があります。

このセッションでは、本番システムでの運用を見据えたアプリケーション開発に必要な知識や勘所を紹介します。

主に初級～中級のエンジニア向けを想定していますが、特に初学者の方にとっては中級へステップアップできる糸口になるかと思います。  
途中で紹介するサンプルコードにはDjangoを例に用いますが、特定のフレームワークに依存しない汎用的な内容となるように注意します。

- 実装
  - ORM
  - テスト
  - エラーハンドリング
- 設定ファイル
  - セキュリティ
  - 環境の使い分け
  - ロギング
- スケーラビリティ
- その他
  - コンテナ化

Shota Kokado

あなたのアプリケーションを本番システムで動かすために

Ever heard of syntactic sugar? Its syntax that makes code easier to read, write, and understand... and Python is full of it! In this talk, we'll dive into some of Python's most powerful syntactic sugar including decorators, context managers, and more. Whether you're new to Python or experienced, you'll walk away from this talk with tips and tricks to effortlessly write slick, readable code.

The following are the topics I plan to discuss in this talk:
- Decorators
- Context managers
- List Comprehensions
- Ternary Operators
This talk will break down each topic so that newcomers can understand these more advanced concepts and folks who have experience with Python can get a refresher on how they work.

Uma Annamalai

The Best of Python: A Review of Some of its Slickest Features

The key of debugging is observability and reproducibility. It is still challenging to see what’s happening in complex real-world asyncio applications. To tackle this problem, I wrote the new, improved version of aiomonitor based on my fork by collaboration with the aio-libs maintainers met in person in PyCon US 2023. This talk will present the challenges of asyncio debugging, how I improved the ex

When we compose multiple asyncio libraries and our own codes together, it is hard to track down silently swallowed cancellations and resource-hogging floods of tasks triggered by internals of 3rd-party callbacks. Moreoever, such misbehaviors are often observed only in production environments where the app faces the actual workloads and I/O patterns, making it even harder to reproduce.

The aio-libs/aiomonitor project provides a live access to a running asyncio process using a telnet-based REPL interafce to inspect the list of tasks and their current stacks. I have added more features to help tracking the above issues of asyncio apps running in production: task creation tracker and termination tracker. These trackers keeps the stack traces whenever a new task is created or terminated, and provides a holistic view of chained stack traces when the tasks are nested with arbitrary depths. aiomonitor also demonstrates a rich async TUI (terminal UI) based on prompt toolkit and Click, with auto-completion of commands and arguments, far enhancing the original version’s simple REPL. With aiomonitor, I could successfully debug several production bugs. 

In PyCon US 2023, I’ve presented my fork, aiomonitor-ng, and collaborated with Sviatoslav Sydorenko (@webknjaz) to backport it to the original project while revamping the CI/CD pipelines. This talk will also cover the stories of the backporting process.

I hope this talk would help our fellow asyncio developers to build more complex yet stable applications at scale.

Joongi Kim

Improving debuggability of complex asyncio applications

We introduce a novel design approach to design, develop, deploy, and maintain AI/ML tools. This real-world research case study in the healthcare domain, to solve societal issues, can provide actionable methodology for any DevOps task using Python. The presented design methods demonstrate how Python is used in all stages of research with data collected from 60 million patients in United Kingdom.

In healthcare, the use of machine learning (ML) and artificial intelligence (AI) is becoming popular than ever, and Python is in the forefront when it comes to the programming language of choice.

In this talk, we outline the use of a design and implementation framework to aid developers to design _Human-Centered AI (HcAI)_ solutions in healthcare. We provide examples from our research to showcase challenges and best practices of using large healthcare datasets such as [CPRD](https://cprd.com) in the UK consisting of data collected from 60 million patients, where we analyse and develop AI/ML models using Python. This will allow the audience to get a good understanding of the challenges involved in solving technical and societal issues such as in healthcare. It will demonstrate as a case study of research in United Kingdom as to how widespread adoption of Python, combined with design innovation can lead to accountable, transparent, and safe use of AI/ML tools.

Participants of the talk will be able to appreciate how this approach can make their **design, development, deployment, and maintenance** well organized and sustainable. Beginners as well as advanced users are often not familiar with the real-world utility perspectives of AI/ML development, and this talk will provide the international community with actionable take-home ideas that they can use in their projects. It will demonstrate how using Python can make even such data-driven complicated tasks more manageable.

The talk will also be accompanied by a poster, which will provide the audience to interact with the speakers beyond the talk. Furthermore, we open up the Q&A session to include a collaborative platform at an international level for anyone from the audience who might be interested to engage in our research work, for future collaboration.

### Talk outline and organization
- Introduction to Human-Centered AI Design using Python ```(5 mins)```
- Examples from the read-world research settings ```(2 mins)```
- Challenges, best practices, and Python tools used to research on database with 60 million patients in United Kingdom ```(3 mins)```
- How to use the Health AI Implementation Framework in research ```(5 mins)```
- Interactive Demo: Examples from ongoing research work using Python ```(10 mins)```
- Q&A from the audience ```(5 mins)```

### Audience
This talk is aimed for Python **beginners** as it provides design and implementation guidance in AI/ML development, deployment, and maintenance. **Advanced users** will also benefit from this approach and be able to develop solutions using this implementation framework. The talk would also be suited for **policy makers** and **project + product management team members** so that they can use the approach in their companies. Researchers in this field can also take away actionable perspectives for research studies. Although the main example is in healthcare, the design principles described in the talk is applicable to any large scale AI/ML development.

Hassan Sami Adnan

Samara Sharmeen

Python in Human-Centered AI Design: How to deal with 60 Million patients to develop AI solutions in healthcare

Python's role in the video industry and high-tech research is undeniable. But how well does it bridge the gap between video enhancement research and the industry? This talk explores the challenges of integrating Python with real-world datasets to achieve high-quality videos. Join us as we delve into the complexities. Don't miss this opportunity to explore the future of video+Python.

In this thriving AI era, groundbreaking research and technologies emerge constantly. The Computer Vision revolution sparked the AI movement with milestones like AlexNet in 2012. However, many academic codebases lack the complexity and real-world challenges of industry data. Python, a driving force in AI, is often used for research implementation but falls short in integrating cutting-edge algorithms into complete video pipelines.

Join us as we share our experiences, experiments, and insights applying state-of-the-art video enhancement research to premium content. We'll delve into the challenges faced when bridging academic Python codebases, research datasets, real-world video content, and video processing pipelines. 

Explore:
    - Types of video quality enhancement research and their significance
    - The gap between SOTA video research and the industry
        - Python codebase considerations
        - Handling diverse video datasets effectively
        - Optimizing video processing pipelines
    - Strategies to narrow the gap and achieve seamless integration
    - Engaging demonstrations showcasing enhanced videos across various domains

Don't miss this enlightening session where we unravel the complexities of implementing advanced video research and explore ways to revolutionize the industry with Python.

Shuen-Huei Guan

Real²-World Video Quality Enhancement

Monorepo とは複数のプロジェクトやアプリケーションのソースコード、リソースを分割せずに全てを 1 つのリポジトリで管理するリポジトリ構成のことです。Monorepo を採用することでコードの共有が容易になり、コードの重複を減らすことができます。統一的な管理によりコード品質も一定保てるためチーム開発と相性が良く、うまく活用することでメンテナンス性や開発者体験を向上できます。

ビルドシステムの Pants は Python をサポートしており、CADDi ではサーバーサイドのアプリケーション開発や機械学習プロジェクトなどを Monorepo で管理しています。本セッションでは、Pants の活用方法と CADDi の Monorepo 移行・運用によって得られた知見を共有します。

## 概要

Monorepo で管理することによって開発に必要なリソースが全て 1 つの場所に集約され、リポジトリに関わる全員が共通の開発プロセスやツールを使用できます。これによりリンター、フォーマッター、テスト、CI/CD などの開発ツールの統一が容易になります。車輪の再発明を減らし、コード品質も一定に保てる Monorepo はチーム開発と相性が良く、うまく活用することでメンテナンス性や開発者体験を向上できます。

### Monorepo における課題

Monorepo を採用する上で依存関係の管理や差分検知といった課題がありますが、これらはビルドシステムによって解決できます。

- 依存関係: リポジトリ内の依存を明示的に記述することもできますが、Pants は依存関係を推測する機能があるため依存関係の記述をシンプルにできます。
- 差分検知: Monorepo には複数のプロジェクトが存在し、毎回の CI 実行で変更と関係ないプロジェクトまでテストすると時間とお金がかかります。一方で、変更によって影響を受けるコードがテストされなかった場合、コードが壊れていることを検知できず広範囲に影響を及ぼすことがあります。Pants は差分検知をサポートしているので、変更されたファイルのみを対象に実行できます。
- 実行: コンパイルをして実行ファイルを生成するプログラミング言語であれば、実行ファイルをコンテナ環境などに配置し実行することができます。しかし、Python は実行ファイルを生成しません。実行に必要なファイルを手動で選択して配置しなくていいように、Pants は pex という Python 実行ファイルを生成するツールをサポートしています。これにより依存するソースから実行ファイルを生成してコンテナ環境などで実行できます。

## 予定稿

- 自己紹介
- 本セッションの概要
- Monorepo と Polyrepo について

  - それぞれの特徴
  - メリット・デメリット

- Pants について

  - Pants の概要
    - Pants の特徴
    - Pants がサポートしているプログラミング言語とフレームワーク・ツール

- Pants を使った Monorepo のはじめかた

  - フォーマッター、リンターの静的解析
    - Pants がサポートしている静的解析について
  - テスト
    - CI/CD
  - 差分実行
  - 依存関係の管理

    - 3rd party ライブラリの依存管理
    - Monorepo 内の依存管理

  - pex について
    - 3rd party ライブラリの依存の内包

- Poetry を使った Polyrepo から Monorepo への移行事例

  - 移行の背景
  - 移行の手順
  - Monorepo での開発
    - ブランチ戦略
  - 移行後
    - リポジトリ依存関係の統一
  - 今後の展望

- まとめ

## 話さないこと

- Bazel や Buck2、Moon、NX といった Pants 以外のビルドシステムの詳細

Koki Nishihara

Pants ではじめる Python Monorepo

法律は誰にとっても重要な存在でありながら、その難解さから普段は敬遠してしまいがちです。この発表ではPythonを駆使したデータ分析・可視化により、法律に見え隠れする日本の歴史や日本の法律の特徴などを聴衆の全員に分かりやすく示します。  
発表では自然言語処理とGIS（地理情報システム）による分析に注目します。自然言語処理では法律データの条文のテキスト分析することで様々なインサイトが得られました。更にGISを活用した分析で、法律や条文に含まれる地名に基づき法律に緯度経度を付与することで、法律を地図上に可視化することが可能になりました。  
 Pythonist が法学のドメイン知識に触れる機会は、学術的にも社会的にも貴重だと考えます。また可視化によって法律を分かりやすく伝える試みは専門知識のコミュケーションとしても価値がある営みだと考えます。

法律は誰にとっても重要な存在でありながら、その難解さや複雑さから実際の条文を眺めたり意味を考えたりする人は法律家を除けばまれでしょう。しかし法律こそがあなたが危機に陥ったときに助けてくれたり、あなたが何かに挑戦しようとしたときにサポートをしてくれる存在の正体です。こうした法律を分析・可視化することで聴衆に法律にまつわるテーマを分かりやすく伝える試みは社会的意義が大きいと考えます。
  
この発表ではPythonを駆使して法律データをテキスト分析したり、法律を地理空間情報として地図に可視化したりすることによって、法律に見え隠れする日本の歴史や日本の法律の特徴などを聴衆の全員に分かりやすく示します。

発表では、デジタル庁が公開しているXML形式で構造化された法律データ及び国立国会図書館の日本法令索引データを用います。

発表で焦点を当てる分析手法は、自然言語処理とGIS（地理情報システム）の大きく２つです。

自然言語処理では、XML形式で公開されている法律データを Python を使ってパースすることで様々な特徴量を抽出します。これらと法律のメタデータ（施行年など）をクロス分析することで、戦前戦後での法の形態の変化など様々なインサイトが得られます。

GIS（地理情報システム）を活用した分析では、法律や条文に含まれる地名に基づき法律に緯度経度を付与（ジオコーディング）することで、法律を地図上に可視化することが可能になります。地図可視化により、明治維新(1868年)後の北海道開拓や沖縄返還(1972年)など歴史的な出来事が浮かび上がったり、各地の文化や世界遺産などローカルな特色に紐づく法律の姿が垣間見えたりしました。また、こうした地図上の可視化により聴衆がインサイトを直感的に理解することができます。

こうしたテーマは計量法学（ジュリメトリックス）の一部とされます。しかし、計量法学は日本ではまだ発展途上です。 Pythonist やフロントエンドエンジニアが法学のドメイン知識に触れることで、学術的にも社会的にも意義のある新たな発想が生まれる機運になるかもしれません。また、可視化によって法律を分かりやすく伝える試みは、法学の専門知識の大衆へのコミュケーションとしても価値がある営みだと考えます。

現時点で想定している構成とタイムラインは次の通りです。

- 導入（3min）
    - 自己紹介
    - プレゼンの概要と目的
- 法律データについて（7min）
    - 日本の法律のしくみについて
    - 計量法学（ジュリメトリックス）について
    - デジタル化された法律データ（XML形式）のしくみについて
    - 世界での法律データのデジタル化の状況について
- 法律データのテキスト分析（10min）
    - 自然言語処理の概要の説明
    - 法律に特有なテキスト分析手法の説明
    - テキスト分析で得られたインサイト
- 法律データの地図可視化（10min）
    - 地理情報システム（GIS）地理空間情報について
    - ジオコーディング（地名から緯度経度を推定）について
    - 地図可視化の手法説明
    - 可視化の結果および解釈
- まとめ（2min）

実例として挙げる Python スクリプト（とライブラリ）は以下を現時点では予定しています。

- 法律データを自然言語処理・分析するスクリプト
    - MeCab
    - PyGeoNLP
    - Pandas
    - XML2Dict
- 分析結果を地図上に可視化するスクリプト
    - Geopandas
    - Plotly
    - Leaflet

Ryo Namiki

Python x 法学〜日本の法律のテキスト分析と地図可視化への試み〜

ソーシャルログイン機能は、Webサービスの認証方法として広く利用されており、Python Social Authなどのライブラリを使用することで、この機能を容易に実装することができます。一方で、外部サービスに依存するという性質上、外部要因によってシステムの変更が必要になるリスクがあるのも事実です。実際、2023年2月にはTwitterが旧APIの廃止を発表し、多くのWebアプリケーションが影響を受けました。

本セッションでは、実際に行った「Python Social Auth の Twitter OAuth API マイグレーションプロジェクト」を振り返りながら、具体的な対応策やソーシャルログイン機能の構築に関するTipsを紹介します。ユーザーへの影響を出してしまったプロジェクトでもありますが、得られた教訓を共有したいと思います。

### 予定稿

- 自己紹介
- 概要説明
- 前提知識の共有
  - ソーシャルログインについて
  - Python Social Authについて
- Twitter API マイグレーションの経緯
  - LAPRAS(題材となるシステムの紹介)
  - 2023の発表から、影響調査、対応方針決定など
- マイグレーションの課題と対応方法
  - Python Social Authの内部構造
  - 運用中のサービスの認証/認可プロバイダを変更することによる課題
    - 課題1 - 同じユーザでも認証(認可)プロバイダが異なると別人として扱われる
    - 課題2 - サービス名とProvider名が一致しなくなる
  - 移行作業の注意点
- マイグレーションプロジェクトの結果
- 学び(システム面, 運用面)
  - システム面
    - Provider名をサービス名として直接使用しない
    - ProviderとSNSの関係を1:1を前提としない
  - 最悪を想定して計画を立てる
  - 計画の前提にしている事実を明確にしておく
- まとめ

Takanori Koroki / rocky_manobi

実録 Python Social Auth の Twitter OAuth APIマイグレーションプロジェクトとその教訓

My old high school needs help with some research projects that involves coding. Instead of just helping, I convinced them to offer a python programming class instead! **This talk will discuss the journey on how this whole idea began and how it was executed. We will also discuss my grand plan of having every high school in our city to add a python programming class!**

In order to understand the core problem, I will first give a glimpse of the education system here in the Philippines. This is to cement the underlying need for implementing a programming class for high school students.

There are a lot of factors that we need to consider when we were planning this class. It might seem simple and straightforward but we had to adjust the coverage and scope of what we want to offer due to the needs of the students and the school. 

We encountered a lot of problems including how to pick the correct teachers and how to teach the teachers themselves. As for the students, we want to make sure that they can use what they will learn in their research and projects. 

It has been a couple of years since the school added programming classes and they were able to offer it to different grade level already. We have some insights on how it affected the students and how it made them more inclined towards STEM (science, technology, engineering, maths).

Moving forward, my grand plan is to make all the schools in our city teach python and programming. I am in talk with the other schools and I want to make sure that they can implement a python programming class as well. I want to make this as an opportunity to show other schools and the local government how adding a python programming class can actually improve the quality of research output for students.

The talk will focus on the following main key points:

- Education challenges in the Philippines in the context of tech and programming
- How did we came up with the idea of adding python programming to the curriculum
- How did we implement it?
- What are the key takeaways and how do we plan to improve the python programming class
- The grand plan of spreading this to all the schools in our city!

Timetable