semvec/pypi-packages huggingface dataset:
dbrw 0.1.14
DataBase Reader and Writer utilities
Requires Python: >=3.6

# dbrw

Postgres DataBase Reader and Writer utilities.

## Installation

```bash
pip install dbrw[psycopg2]
```

or

```bash
pip install dbrw[psycopg2-binary]
```

## Basic Usage


```bash
export DBRW_PGHOST=localhost
export DBRW_PGPORT=5432
export DBRW_PGDBNAME=postgres
export DBRW_PGUSER=postgres
export DBRW_PGPASSWORD=postgres
export DBRW_PGPOOLSIZE=10
```

```python
from dbrw import DbSession, DbUtilities

session: DbSession = DbSession()
db: DbUtilities = session.get_db()

db.execute("SELECT * FROM mytable;")
```
VDP 0.1.0
Variational Density Propagation (VDP) CNN Layers for TensorFlow
Requires Python: >=3.6

The original code can be found on Github [here](https://github.com/dimahdera/PremiUm-CNN-CIFAR10-Tensorflow-2.x/tree/main).

This PyPi package was written to simplify imports in subsequent projects, experiments and replications. 

Principle Researcher: [Dr Dima Dera](https://www.linkedin.com/in/dimah-dera-925aa532/).
sympyhelpers 1.3.0
Helper routines for sympy
Requires Python: >=3.9

# sympyhelpers

Helper routines and definitions for sympy.  In particular, these methods wrap existing `sympy` functionality to do Newton-Euler and Lagrangian mechanics using Kane-style and Newton notation and format the outputs to match (some of) the conventions used in various textbooks including Kasdin & Paley (2011).

[![Documentation Status](https://readthedocs.org/projects/sympyhelpers/badge/?version=latest)](https://sympyhelpers.readthedocs.io/en/latest/?badge=latest)
[![PyPI version](https://badge.fury.io/py/sympyhelpers.svg)](https://badge.fury.io/py/sympyhelpers)



## Installation 

`sympyhelpers` is pip installable.  Just run:

```
pip install sympyhelpers
```

## Documentation
Click on the 'docs' badge, above, or navigate to: https://sympyhelpers.readthedocs.io/
django-query-index-analyzer 0.1.4
CLI tool to analyze Django ORM filter, exclude, and annotate usage on a specific model.
Requires Python: >=3.8

# README.md

# record-query-analysis

**record-query-analysis** is a command-line tool for analyzing Django ORM usage of `.filter()`, `.exclude()`, and `.annotate()` on a specific model across a Python codebase.

## 🔍 Features
- Detects chained querysets on a target model (e.g., `Record.objects.filter(...).annotate(...)`)
- Extracts used fields in `filter`, `exclude`, and `annotate`
- Aggregates and counts unique field combinations
- Outputs results in **table**, **JSON**, or **CSV** formats

## 🚀 Installation
```bash
pip install -e .  # or build via uv, poetry, etc.
```

## 🧪 Usage
```bash
record-query-analysis path/to/your/codebase --model=Record --output-format=table
```

### Options:
- `--model`: Django model name (default: `Record`)
- `--output-format`: `table` (default), `json`, or `csv`
- `--csv-file`: custom file path for CSV output

## 📦 Example Output
```text
Filter/Exclude Fields                  | Annotate Fields           | Frequency | Locations
-----------------------------------------------------------------------------------------------
is_active, location_id                | client                    |        12 |
                                                                ↳ app/views/reports.py:45
```

## 📄 License
MIT License
blang 0.1.3
A compiler for burb lang.
Requires Python: >=3.12

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)

# BLang - A Minimal Programming Language

This is a toy programming language with its own compiler backend that emits x86_64 assembly. It supports basic types, arrays, pointers, functions, conditionals, loops, etc. The compiler is written in Python. 

## Why?

Just for fun. I wanted to learn how compilers work at a deeper level, and this was a great way to explore parsing, code generation, memory layout, calling conventions, etc.

## Is it useful?

Probably not. It's not fast, it's not safe, it's not feature-complete, and it doesn't have a standard library. But the code is (mostly) readable, and it covers a lot of core ideas behind compiling a high-level language down to raw machine code.

## Running

Install NASM. 

To compile a .bl source file to a native executable:

blangc your_program.bl -o your_program

To run tests:

pytest tests/

## Current Features

- Integers (signed/unsigned), doubles
- Arrays and pointers
- Functions (multiple arguments, stack handling)
- Conditionals (if, else)
- Loops (while, for)
- Bitwise operations (&, |, ^)
- String literals and basic string handling
- Assembly output using NASM
- Simple CLI compiler
- CI build and test pipeline

## Missing / Incomplete / Won't Do

- No type inference or advanced type checking
- No heap allocation or garbage collection
- No standard library
- Limited error reporting
- No optimization passes
- No inline assembly or macros (yet)
- No structs

## License

MIT

## Example programs
See `examples/`