semvec/pypi-packages huggingface dataset:
d64py 3.2.0
Cenbe's Commodore 64 Disk Image Library
Requires Python: >=3.13
Keywords: Commodore, GEOS

### This project is a Python library for writing programs to explore Commodore 64 disk images; my Disk Wrangler (q.v.) is based on it. It's particularly good at dissecting GEOS disks. Here's how to get started:

**Create a DiskImage object. Just pass a Path to the constructor; he'll detect the image type (or raise an Exception if it's not one):**

```
from pathlib import Path
from d64py.DiskImage import DiskImage
from d64py.Constants import CharSet

path = Path("/your/image/here.d64")
image = DiskImage(path)
```

**Now you can read the directory:**

```
dirEntries = image.getDirectory()
for dirEntry in dirEntries:
    print(f"{dirEntry.getDisplayFileName()}")
```

**If you have a GEOS file, you can access the fields in the file header:**

```
    if dirEntry.isGeosFile():
        geosFileHeader = dirEntry.getGeosFileHeader()
        print(f"permanent name string: {geosFileHeader.getPermanentNameString()}")
```

**Say there's a geoWrite file on the disk, and you'd like to quickly see what's in it. We can ask the disk image to find the directory entry for us (if we specify CharSet.PETSCII, the filename will be translated to PETSCII first). All the routines that return lines of text return TextLine objects, which is just a helper class that includes a line of text and an error flag (for e.g. printing in red). geoWrite files return a list of pages, each of which is a list of TextLines.**

```
dirEntry = image.findDirEntry("firstBootSrc", CharSet.ASCII)
pages = image.getGeoWriteFileAsLines(dirEntry)
for page in pages:
    for line in page:
        print(line.text)
```

**Don't forget to release the image's resources when you're through with it (the entire image gets memory-mapped):**

```
image.close()
```
dlt-source-notion 0.0.9
A DLT source for notion
Requires Python: >=3.12

---
description: dlt source for notion.com
keywords: [notion API, notion.com]
---

# dlt-source-notion

[![PyPI version](https://img.shields.io/pypi/v/dlt-source-notion)](https://pypi.org/project/dlt-source-notion/)

[DLT](https://dlthub.com/) source for [notion](https://www.notion.com/).

Currently loads the following data:

| Table | Contains |
| -- | -- |
| `persons` | Items of the `user` model of type `person` |
| `bots` | Items of the `user` model of type `bot` |
| `database_<name>_<shorthash>` | The database content (pages) of a given database. Columns are all global page columns + selected columns of properties |
| `databases` | All metadata of each loaded database. Has the title and a reference to the database table as well. |
| `databases__properties` | Column \<-> Label mapping for each unfiltered database property |
| `options_<name>_<shorthash>` | All options of a `select` or `multi_select` in one of the loaded databases. |

`<shorthash>` refers to the hashed `id` of an entity.
The hash is a 4-bit BLAKE2b hash.

## Why are you not using the `dlt-hub/verified-sources` notion source / Differences

The [official verified source](https://github.com/dlt-hub/verified-sources/tree/master/sources/notion)
has a few drawbacks:

- on usage of the verified source, a copy of the current state of
  the `dlt-hub/verified-sources` repository is copied into your project;
  Once you make changes to it, it effectively becomes a fork,
  making it hard to update after the fact.
- This makes use of a preexisting client implementation
- And Pydantic types for Notion entities,
  which makes this implementation a lot more stable

## Usage

Create a `.dlt/secrets.toml` with your API key and email:

```toml
notion_token = "ntn_abcd12345"
```

and then run the default source with optional list references:

```py
from dlt_source_notion import source as notion_source

pipeline = dlt.pipeline(
   pipeline_name="notion_pipeline",
   destination="duckdb",
   dev_mode=True,
)
notion_data = notion_source()
pipeline.run(notion_data)
```

## Development

This project is using [devenv](https://devenv.sh/).

Commands:

| Command | What does it do? |
| -- | -- |
| `format` | Formats & lints all code |
| `sample-pipeline-run` | Runs the sample pipeline. By default `dev_mode=True` which fetches resources with a limit of 1 (page) |
| `sample-pipeline-show` | Starts the streamlit-based dlt hub |

### Run the sample

```sh
NOTION_TOKEN=[...] \
  sample-pipeline-run
```

alternatively you can also create a `.dlt/secrets.toml`
(excluded from git) with the following content:

```toml
notion_token = "ntn_abcd12345"
```
d64gfx 1.1.0
Graphics Routines for Cenbe's Disk Wrangler
Requires Python: >=3.13
Keywords: Commodore, GEOS

### These are the graphics routines for Cenbe's Disk Wrangler, an explorer for Commodore 64 disk images written in Python and Qt.

They were split off into a separate project so that programmers wanting
to use the d64py library for text-based programs wouldn't need to
import all of the Qt libraries as well.
topsis-ishwin-102303644 1.0.2
TOPSIS implementation as a Python package

# TOPSIS Python Package

This package implements the **TOPSIS (Technique for Order Preference by Similarity to Ideal Solution)** method.

## Installation

```bash
pip install topsis-ishwin-102303644
```

## Usage

```bash
topsis data.xlsx "1,1,1,2,1" "+,+,-,+,+" output.xlsx
```

## Input Format

* First column: Alternatives
* Remaining columns: Numeric criteria

## Output

* Adds **Topsis Score**
* Adds **Rank**

## Example

```bash
topsis sample.xlsx "1,1,1,2,1" "+,+,-,+,+" result.xlsx
```

## Author

Ishwin