semvec/pypi-packages huggingface dataset:
hello-rust-pyo3 0.1.0
Small example of a Rust extension module for Python using PyO3 + maturin.
License: MIT
Requires Python: >=3.8

# hello-rust-pyo3

Minimal **Rust** extension for Python using **PyO3 + maturin**.

## Quick test (local)

```bash
python -m venv .venv
# Windows: py -3.12 -m venv .venv
source .venv/bin/activate  # Windows: .\.venv\Scripts\Activate.ps1
python -m pip install -U pip maturin
maturin develop  # builds & installs into the venv

python -c "import hello_rust_pyo3 as m; print(m.add(2,3), m.greet('Sequa'))"
```

## Build wheels / sdist

```bash
maturin build --release --out dist           # wheels
maturin build --release --sdist --out dist   # add sdist
```

## Verify & Publish

```bash
python -m pip install -U twine
python -m twine check dist/*
# TestPyPI
python -m twine upload -r testpypi -u __token__ -p <TESTPYPI_TOKEN> dist/*
# PyPI
python -m twine upload -r pypi -u __token__ -p <PYPI_TOKEN> dist/*
```

## Notes (Windows/macOS/Linux)

- Install Rust toolchain: https://rustup.rs/
- Windows: install Microsoft C++ build tools (Visual Studio Build Tools).
- macOS: Xcode Command Line Tools (`xcode-select --install`).
- Linux: ensure `gcc`/`clang` and Python dev headers are installed.
termux-openai 1.0.0
OpenAI Python client fork for Termux (no Rust/jiter required)
License: MIT
Requires Python: >=3.8

# Termux-OpenAI

Termux uyumlu OpenAI Python client 📱🐍  
Rust bağımlılığı yok, `jiter` yok → direkt kurulabilir.

## Kurulum
```bash
pip install termux-openai
birdseye 0.10.0
Graphical Python debugger which lets you easily view the values of all evaluated expressions
License: MIT
Requires Python: >=3.8

|logo| birdseye
===============

|Supports Python versions 3.8+|

birdseye is a Python debugger which records the values of expressions in a
function call and lets you easily view them after the function exits.
For example:

.. figure:: https://i.imgur.com/rtZEhHb.gif
   :alt: Hovering over expressions

You can use birdseye no matter how you run or edit your code. Just ``pip install birdseye``, add the ``@eye`` decorator
as seen above, run your function however you like, and view the results in your browser.
It's also `integrated with some common tools <http://birdseye.readthedocs.io/en/latest/integrations.html>`_ for a smoother experience.

You can try it out **instantly** on `futurecoder <https://futurecoder.io/course/#ide>`_: enter your code in the editor on the left and click the ``birdseye`` button to run. No imports or decorators required.

Feature Highlights
------------------

Rather than stepping through lines, move back and forth through loop
iterations and see how the values of selected expressions change:

.. figure:: https://i.imgur.com/236Gj2E.gif
   :alt: Stepping through loop iterations

See which expressions raise exceptions, even if they’re suppressed:

.. figure:: http://i.imgur.com/UxqDyIL.png
   :alt: Exception highlighting

Expand concrete data structures and objects to see their contents.
Lengths and depths are limited to avoid an overload of data.

.. figure:: http://i.imgur.com/PfmqZnT.png
   :alt: Exploring data structures and objects

Calls are organised into functions (which are organised into files) and
ordered by time, letting you see what happens at a glance:

.. figure:: https://i.imgur.com/5OrB76I.png
   :alt: List of function calls

.. |logo| image:: https://i.imgur.com/i7uaJDO.png
.. |Supports Python versions 3.8+| image:: https://img.shields.io/pypi/pyversions/birdseye.svg
   :target: https://pypi.python.org/pypi/birdseye

.. inclusion-end-marker

**Read more documentation** `here <http://birdseye.readthedocs.io>`_
databricks-optimize 0.2.2
Databricks utility to identify which column to use for z-ordering and partitioning.
License: MIT
Requires Python: >=3.8

# Databricks optimize utility
Library to generate more easily optimize statement based on existing data.

## Build from source
Build the wheel file is enough to run
```
python -m build --wheel
```

## Table optimizer
This object can be initialized with a table object name (with three level namespace "catalog.schema.table"), the method pre_optimization will run some statistics to identify the best column to run z-order (column with highest cardinality) and to re-partition (this depends on the size of the table and the size of the generated files partition). This is used to define and print the optimization query. Then to run the optimization itself we have two additional method, run_optimize and run_partition, these two can be executed even on their own without the need to run the pre_optimization, in this case the method will run the statistics and the generation separately.


```
from dbks_optimize.optimizer import TableOptimizer

opt = TableOptimizer(spark,"testing.bakehouse.sales_customers",force_partition_on_col='customerID')

opt.pre_optimization() #print out the optimization statement

opt.run_optimizer() #execute optimize on the table

opt.run_partition() #execute partitioning query (it clone i a new table and overwrite the existing one)
```

## Schema optimizer
This object leverage the existing class for single table object and iterate over list of table available computing table statistics.
pre_optimize is used to generate the optimize statement, while to run real optimization we can use run_db_optimization.

```
from dbks_optimize.optimizer import SchemaOptimizer

opt = SchemaOptimizer(spark,'testing.bakehouse')

opt.pre_optimization()

opt.run_db_optimization()
```

## Catalog optimizer
Using the same logic iterate over all schemas and for each on on all tables to generate the statement.
```
from dbks_optimize.optimizer import CatalogOptimizer

opt = CatalogOptimizer(spark,'testing')

opt.pre_optimization()

opt.run_catalog_optimization()
```
signal-ICT-DevarshBhatt-92400133073 2.0.0
Python package for signal generation and operations
License: MIT
Requires Python: >=3.6

# Signal Processing Package â€“ Devarsh Bhatt (92400133073)

This Python package provides basic signal processing operations and generation of common signals (unit step, ramp, trigonometric signals, etc.).  
It was developed as part of the ICT Lab project.

---

## ðŸ“¦ Package Modules
- *unitary_signals.py* â†’ Contains functions for unit step, ramp, impulse signals.
- *trigonometric_signals.py* â†’ Functions to generate sine and cosine signals.
- *operations.py* â†’ Functions for operations like time shift, time scaling, amplitude scaling, etc.
- *_init_.py* â†’ Makes the package importable.

---

## âš™ Installation

### 1. From Wheel (local)
After building, a .whl file will be present in the dist/ folder.  
To install locally:

```bash
pip install dist/signal_ICT_DevarshBhatt_92400133073-0.1.0-py3-none-any.whl
ardot-permit-officer 1.0.1
Fetch ARDOT permit officer contact info from all 10 district pages.
License: MIT
Requires Python: >=3.7

# ardot_permit_officer

A Python package to fetch ARDOT permit officer contact information from all 10 district pages.

## Features
- Scrapes name, email, and phone number for each district's permit officer
- CLI tool to print or export the data


## Usage

### Command Line

Install the package (from PyPI or locally):

```bash
pip install ardot_permit_officer
```

Run the CLI to print all permit officer info as JSON:

```bash
ardot-permit-officer
```

### Python API

You can also use the package in your own Python code. You can choose between dict (default) or object-oriented (Officer class) results:

#### Get all permit officers (dicts)
```python
from ardot_permit_officer.scraper import get_all_permit_officers
officers = get_all_permit_officers()
for officer in officers:
	print(officer['email'])
```

#### Get all permit officers (objects)
```python
from ardot_permit_officer.scraper import get_all_permit_officers_obj
officers = get_all_permit_officers_obj()
for officer in officers:
	print(officer.email)
```

#### Get a single district's permit officer (dict)
```python
from ardot_permit_officer.scraper import get_permit_officer_by_district
officer = get_permit_officer_by_district(7)  # For district 7
print(officer['email'])
```

#### Get a single district's permit officer (object)
```python
from ardot_permit_officer.scraper import get_permit_officer_by_district_obj
officer = get_permit_officer_by_district_obj(7)
print(officer.email)
```

## Publishing
Publishing to PyPI is automated via GitHub Actions. See `.github/workflows/publish.yml`.
pgeng 1.8.5
Useful functions and classes for PyGame
License: MIT
Requires Python: >=3.6

# pgeng
Useful functions and classes for pygame

### Installation
`pip3 install pgeng -U`
### Documentation
Run `help(pgeng.<Function>)` to get the documentation of the function (or possibly class)\
Or run `help(pgeng.<Package Content>)` to get the documentation of the functions or classes in a file
```py
import pgeng
help(pgeng)
```
---
### Credits
Thanks to [tank-king](https://github.com/tank-king) for the [flame](https://github.com/marekromk/pgeng/blob/main/pgeng/vfx/flame.py) ([tutorial](https://youtu.be/MJB3QPXUYBU))\
Thanks to [DaFluffyPotato](https://github.com/DaFluffyPotato) for all his [tutorials](https://youtube.com/playlist?list=PLX5fBCkxJmm1fPSqgn9gyR3qih8yYLvMj)

### License
This project is licensed under the terms of the MIT license.\
For reference, see [LICENSE](https://github.com/marekromk/pgeng/blob/main/LICENSE)