semvec/pypi-packages huggingface dataset:
acheron 3.0.0
Plotting and recording program for Asphodel devices
Requires Python: >=3.10
Keywords: asphodel suprock apd

# Acheron

## About
Acheron is a plotting application and data recorder for USB and TCP devices communicating via the Asphodel protocol.

The Asphodel communication protocol was developed by Suprock Technologies (http://www.suprocktech.com)

## License
Acheron is licensed under the ISC license.

The ISC license is a streamlined version of the BSD license, and permits usage in both open source and propretary projects.

## Pronunciation
Commonly pronounced as "ACK-er-on" in English. The word comes from Greek mythology, where Acheron is one of the five rivers in the underworld.
fireflies-assistant 0.2.0
A CLI tool for managing Fireflies.ai meetings and transcripts

# Fireflies Assistant

A command-line interface for Fireflies.ai to manage meeting transcripts and participants.

## Installation

```bash
pip install -e .
```

## Usage

First, set your Fireflies.ai API key:
```bash
ff key YOUR_API_KEY
```

### Commands

- Join a meeting (120 minutes duration):
  ```bash
  ff join
  ```

- List recent meetings:
  ```bash
  ff list
  ff list --limit 20  # Show more meetings
  ```

- Get transcript ID for a meeting URL:
  ```bash
  ff id "https://meet.google.com/abc-def-ghi"
  ```

- Get meeting participants:
  ```bash
  ff participants TRANSCRIPT_ID
  # or use meeting URL
  ff participants "https://meet.google.com/abc-def-ghi"
  ```

- Get meeting transcript:
  ```bash
  ff transcript TRANSCRIPT_ID
  # or use meeting URL
  ff transcript "https://meet.google.com/abc-def-ghi"
  ```

### Data Storage

- API key is stored in `.env` file
- Meeting URL to transcript ID mappings are stored in `~/.fireflies_meetings.json`

## Development

This project uses:
- Click for CLI interface
- python-dotenv for environment management
- requests for API communication
e57 0.2.1a1
Read e57 files to Python. E57 is a compact, non-proprietary point cloud format that's defined by the ASTM E2807 standard.  This format is widely adopted by 3D design applications.
Requires Python: >=3.8
Keywords: pointcloud, e57, lidar

[![PyPI](https://img.shields.io/pypi/v/e57.svg)](https://pypi.org/project/e57)
![GitHub](https://img.shields.io/github/actions/workflow/status/dancergraham/e57-python/CI.yml?branch=main)
![Python Version from PEP 621 TOML](https://img.shields.io/python/required-version-toml?tomlFilePath=https://raw.githubusercontent.com/dancergraham/e57-python/main/pyproject.toml)

# E57 Python Library

E57 is a compact, non-proprietary point cloud format that's defined by the ASTM E2807 standard. This format is widely adopted by 3D design applications.

This python library wraps the [rust e57 library](https://github.com/cry-inc/e57) to provide file reading

- [x] Proof of concept xml reading
- [x] Read e57 point coordinates to numpy array - see `read_points` method.
- [x] Read color field to numpy array.
- [x] Read intensity to numpy array.
- [ ] Read other fields to numpy array.
- [ ] Write to e57 (format ?)

## Getting Started

`pip install e57`

```python
>>> import e57
>>> pc = e57.read_points(r"pointcloud.e57")
>>> pc.points
array([[-23.25304444, -28.17607415, -13.44830654],
       [-23.28290139, -28.02118905, -13.44237764],
       [-23.26799723, -27.9039115 , -13.43430738],
       ...,
       [ 23.2458152 ,  25.4866642 ,  12.45043932],
       [ 23.22830673,  25.58055374,  12.49285875],
       [ 23.25270363,  25.45909652,  12.54284554]])
>>> pc.color
array(([0.3019608 , 0.3529412 , 0.23137255],
       [0.21176471, 0.26666668, 0.12941177],
       [0.21960784, 0.27058825, 0.13333334],
       ...,
       [0.5803922 , 0.58431375, 0.49019608],
       [0.41568628, 0.43529412, 0.33333334],
       [0.21568628, 0.25882354, 0.1254902 ]], dtype=float32)
```

We need a tutorial - could you write one based on our tests?

## Contributing

All contributions welcome - feature requests, bug reports, documentation, sample files, tests, rust code, python code, sharing the project online / via social media, ...

## Testing

`python -m pytest`
hello-ridwaanhall 0.3.0
A package that says hello to Ridwaan

# hello_ridwaanhall

A package that says hello to Ridwaan.

## Installation

```sh
pip install hello_ridwaanhall
```

## Usage

```python
from hello_ridwaanhall import hello, me

print(hello.hi())
print(hello.love())

print(me.username())
print(me.nim())
print(me.name())
print(me.email())
print(me.college())
```
aftonfalk 1.7.1
Makes it easier to interact with sql server using python
Requires Python: >=3.8

# Aftonfalk

Aftonfalk is a module that makes it easier to interact with microsoft sql server. You can see it as an extension to pyodbc

## How to install

```sh
pip install aftonfalk
```

## Example usage

Instantiate a driver:
```python
driver = MssqlDriver(
    dsn="mssql://sa:Password1!@host.docker.internal:31433",
    driver=r"{ODBC Driver 18 for SQL Server}"
)
```

Dropping a table using `execute`

```python
driver.execute(sql=f"DROP TABLE source_system.schema.table;")
```

`read` & `write` data
```python
data = driver.read(query="select * from tablex")
driver.write(sql="INSERT INTO tablex (column_name) VALUES ('column_value')", data=data)
```

Manage tables. Generate them programatically.

```python
from aftonfalk.mssql.enums_ import (
    SqlServerDataType,
    SqlServerTimeZone,
    WriteMode,
    SqlServerIndexType,
)
from aftonfalk.mssql.types_ import Column, Table, Index, Path

source_database = "source_database"
source_schema = "source_schema"

destination_database = "destination_database"
destination_schema = "destination_schema"

DATA_MODIFIED = Column(
    name="data_modified", data_type="DATETIMEOFFSET", constraints="NOT NULL"
)

DEFAULT_COLUMNS = [
    Column(name="metadata_modified", data_type="DATETIMEOFFSET", constraints="NOT NULL"),
    DATA_MODIFIED,
    Column(name="data", data_type="NVARCHAR(MAX)", constraints="NOT NULL"),
]

table_and_key = {
    "FactTable": "FactKey",
    "Dimensiontable": "DimensionKey"
}
tables = {}

for name, key in table_and_key.items():
    tables[name] = Table(
        source_path=Path(database=source_database, schema=source_schema, table=name),
        destination_path=Path(database=destination_database, schema=destination_schema, table=name),
        source_data_modified_column_name="RowUpdatedAt",
        timezone=SqlServerTimeZone.CENTRAL_EUROPEAN_STANDARD_TIME,
        default_columns=DEFAULT_COLUMNS,
        write_mode=WriteMode.APPEND,
        batch_size=200,
        unique_columns=[
            Column(
                name=f"{key}",
                data_type=SqlServerDataType.NVARCHAR.with_length(50),
                constraints="NOT NULL",
            )
        ],
        indexes=[
            Index(
                index_type=SqlServerIndexType.NONCLUSTERED,
                columns=[DATA_MODIFIED]
            )
        ]
    )

```

then you can do things like easily:

creating tables
``` python
driver.create_table(path=table.destination_path, ddl=table.table_ddl())
```

inserting into tables
```python
data = ...
driver.write(sql=table.insert_sql(), data=data)
```