semvec/pypi-packages huggingface dataset:
labdb 1.0.5
MongoDB experiment management tool
Requires Python: >=3.7

# `labdb`

A simple CLI tool for managing MongoDB experiments.

## Installation

Install with:
```bash
pip install .
```

Then, setup with:
```bash
labdb --config
```

## CLI

- no arguments - Start interactive mode
- `pwd` - Show current path
- `ls [path]` - List contents of a path
- `mkdir path` - Create a new directory
- `rm path` - Remove a path (always recursive)
- `mv src_path dest_path` - Move a path to a new location
- `cd [path]` - Change current directory
- `edit path` - Edit notes for a path (directory or experiment)

### Tab Completion

The `labdb` CLI supports tab completion for paths. You can install it automatically with:

```bash
labdb --setup-completions
```

This will automatically detect your shell and add the necessary configuration to your shell's configuration file.

Alternatively, you can manually set it up:
Add the following to your `~/.bashrc` (or similar):
```bash
eval "$(register-python-argcomplete labdb)"
```

## API

Use `ExperimentLogger` and `ExperimentQuery` to programatically log and query experimental data.
386finalproject 0.1.0
First iteration of final project for Stats 386
Requires Python: >=3.10

# Movie Analysis Package (STAT 386 Final Project) 
## Isaac Keenan & Nick Bell

This project analyzes profitability trends in U.S. theatrical films released between 2005 and 2025 using data collected from the TMDB (The Movie Database) API. The project implements a complete data science pipeline including data collection, cleaning, analysis, visualization, documentation, and an interactive Streamlit app.

---

## Project Components

- **Data Collection**
  - Scripts to collect movie IDs and metadata from the TMDB API
  - API rate limits respected during collection
- **Data Cleaning**
  - Filters movies to U.S. theatrical releases with valid budget, revenue, and release dates
    - Final cleaned dataset contains 3,503 movies
- **Analysis & Visualization**
  - Exploratory data analysis and statistical tests
  - Visualizations of profit over time, profit by genre, studio performance, and budget–revenue relationships
- **Interactive App**
  - Streamlit app for interactive exploration of the cleaned dataset
- **Documentation & Report**
  - Quarto website hosted via GitHub Pages
  - Includes package documentation, tutorial, and final written report

---
python-runtime-entity-wrappers 0.1.0a0
A set of small classes to represent Python runtime objects - modules, classes, functions, constants, and abstract instances - in a structured and consistent way.
Requires Python: >=2

# `python-runtime-entity-wrappers`

A set of small classes to represent Python runtime objects - **modules, classes, functions, constants, and abstract
instances** - in a structured and consistent way. This is especially useful for symbolic interpreters, type systems, or
metaprogramming tasks where you need clear semantics of identity and equality for runtime terms.

## Classes

| Wrapper          | What it Represents                                 | Comparison Semantics                          |
|------------------|----------------------------------------------------|-----------------------------------------------|
| Module           | Python module objects                              | By module instance                            |
| Class            | Python class/type objects                          | By class instance                             |
| Function         | Python function or built-in function               | By function instance                          |
| Constant         | Immutable primitive values                         | By value                                      |
| AbstractInstance | *Abstract* instance of a class (not a real object) | By identity (each AbstractInstance is unique) |

---

## Usage

```python
from python_runtime_entity_wrappers import Module, Class, Function, Constant, AbstractInstance

import math

# Module: refers to the 'math' module object
m1 = Module(math)
m2 = Module(math)
assert m1 == m2


# Class: refers to a Python class
class MyClass: pass


c1 = Class(MyClass)
c2 = Class(MyClass)
assert c1 == c2


# Function: refers to a Python function
def foo(): return 42


f1 = Function(foo)
f2 = Function(foo)
assert f1 == f2

# Constant: refers to a literal/primitive value
k1 = Constant(123)
k2 = Constant(123)
assert k1 == k2

# AbstractInstance: refers to an *abstract* instance of a class (not a real Python object)
i1 = AbstractInstance(MyClass)
i2 = AbstractInstance(MyClass)
assert i1 != i2  # Each AbstractInstance(...) is unique (identity equality)
```

## Contributing

Contributions are welcome! Please submit pull requests or open issues on the GitHub repository.

## License

This project is licensed under the [MIT License](LICENSE).