semvec/pypi-packages huggingface dataset:
pybarid 0.1.0
Temporary email client in Python.
Requires Python: >=3.6

# PyBarid

[![Python 3.7+](https://img.shields.io/badge/python-3.7+-blue.svg)](https://www.python.org/downloads/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

Python library for [Barid](https://api.barid.site/) temporary email service.

## Install

```bash
pip install pybarid
```

## Usage

### Sync Mode (Default)

```python
from pybarid import BaridClient

client = BaridClient()

# Generate email
email = client.generate_email()
print(email.full_address)

# Check messages
messages = client.get_messages(email.address, email.domain)
for msg in messages:
    print(f"{msg.from_address}: {msg.subject}")

# Wait for message
message = client.wait_for_message(email.address, email.domain, timeout=60)
if message:
    print(f"New: {message.subject}")
```

### Async Mode (Faster for multiple requests)

```python
import asyncio
from pybarid import BaridClient

async def main():
    client = BaridClient(async_mode=True)
    
    # Generate multiple emails
    emails = await client.generate_emails_batch(5)
    
    # Check messages for all emails concurrently
    all_messages = await client.get_messages_batch(emails)
    
    for email, messages in all_messages.items():
        print(f"{email}: {len(messages)} messages")

asyncio.run(main())
```

## API

### Sync Methods

```python
# Generate email
email = client.generate_email()
email = client.generate_email(domain="example.com")

# Get messages
messages = client.get_messages(email.address, email.domain)

# Wait for message
message = client.wait_for_message(email.address, email.domain, timeout=60)

# Get web inbox
url = client.get_inbox_url(email.address, email.domain)
```

### Async Methods

```python
# Generate email
email = await client.generate_email_async()
email = await client.generate_email_async(domain="example.com")

# Get messages
messages = await client.get_messages_async(email.address, email.domain)

# Wait for message
message = await client.wait_for_message_async(email.address, email.domain, timeout=60)

# Batch operations
emails = await client.generate_emails_batch(5)
all_messages = await client.get_messages_batch(emails)
```

## Credits

Uses [Barid API](https://api.barid.site/) by [vwh](https://github.com/vwh).

---

Made by [oxno1](https://github.com/oxno1)
followme 1.0.1
A command-line tool to track and report URL redirects
Requires Python: >=3.7
Keywords: url, redirect, tracking, command-line, tool

# FollowMe

A command-line tool to track and report URL redirects. FollowMe helps you understand the complete redirect chain of any URL by following each redirect step-by-step and providing a detailed report.

## Features

- Track complete redirect chains for any URL
- Display status codes for each redirect step with color-coded output
- Save reports to files
- Simple command-line interface
- Cross-platform compatibility
- Colorized terminal output (with option to disable)

## Installation

### From PyPI (recommended)

```bash
pip install followme
```

### From source

```bash
git clone git@github.com:rapidrabbitsoft/followme.git
cd followme
pip install -e .
```

## Usage

### Basic usage

```bash
followme https://example.com
```

This will display the redirect chain for the specified URL.

### Save output to file

```bash
followme https://example.com -o redirect_report.txt
```

### Disable colors

```bash
followme https://example.com --no-color
```

### Examples

```bash
# Check a simple redirect
followme https://bit.ly/example

# Check a URL with multiple redirects
followme https://t.co/example

# Save the report to a file
followme https://example.com -o my_report.txt

# Disable colorized output
followme https://example.com --no-color
```

## Output Format

The tool provides a clear, numbered list of each redirect in the chain with color-coded output:

- **Bold text**: Section headers
- **Cyan**: Original URL
- **Yellow**: Step numbers and redirect status codes (301, 302, 307, 308)
- **Blue**: Source URLs in the redirect chain
- **Magenta**: Destination URLs in the redirect chain
- **Green**: Final status codes (200) and "(final)" indicator
- **Red**: Error status codes

```
Redirect chain for https://example.com:
1. https://example.com --[301]--> https://www.example.com
2. https://www.example.com --[200]--> (final)
```

You can disable colors using the `--no-color` flag.

## Requirements

- Python 3.7 or higher
- requests library
- colorama (optional, for Windows color support)

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## Issues

If you encounter any issues, please report them on the GitHub issue tracker.
SecureHardwareExtension 1.0.1
A set of tools for AUTOSAR Secure Hardware Extension.
Requires Python: >=3.8

# Secure Hardware Extension

![CICD](https://github.com/Deejuha/SecureHardwareExtension/workflows/python-test/badge.svg?branch=master)
![Python](https://img.shields.io/pypi/pyversions/Django?style=plastic)

A set of tools for AUTOSAR Secure Hardware Extension.

Available features:

- Generate SHE Memory update protocol messages (M1 M2 M3 M4 M5).
- Parse M1 M2 Memory update protocol messages in order to get the update information.

## Disclaimer

Vector's related specification specifies different layout of `flags` - it uses 5 flags instead of 6, described in AUTOSAR specs as this repo fully follows. Please adjust script accordingly then, I would be glad to some PR propositions if you have anything working. Enjoy!

## Prerequisites

With using Python greater than 3.8 install package to your environment.

```bash
pip install SecureHardwareExtension
```

## Examples

### Calculate M1 - M5 messages by using update info

```py
from secure_hardware_extension.datatypes import MemoryUpdateInfo, SecurityFlags
from secure_hardware_extension.key_slots.autosar import AutosarKeySlots
from secure_hardware_extension.memory_update import MemoryUpdateProtocol
update_info = MemoryUpdateInfo(
    new_key="0f0e0d0c0b0a09080706050403020100",  # Hex string or bytes
    auth_key="000102030405060708090a0b0c0d0e0f",  # Hex string or bytes
    new_key_id=AutosarKeySlots.KEY_1,  # Enum or integer
    auth_key_id=AutosarKeySlots.MASTER_ECU_KEY,  # Enum or integer
    counter=1,
    uid="00" * 14 + "01", # Hex string or bytes
    flags=SecurityFlags(),
)
protocol = MemoryUpdateProtocol(update_info)

protocol.m1
>>> b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01A'

protocol.m2
>>> b'+\x11\x1e-\x93\xf4\x86Vk\xcb\xba\x1d\x7fz\x97\x97\xc9FC\xb0P\xfc]M}\xe1L\xffh"\x03\xc3'
```

### Select apprioprate key slot flags

```py
flags = SecurityFlags()
flags.boot_protection = True
update_info = MemoryUpdateInfo(
    ...
    flags=flags,
)

flags = SecurityFlags(fid=20)
update_info = MemoryUpdateInfo(
    ...
    flags=flags,
)
```

### Get update info from M1 and M2 messages

```py
from secure_hardware_extension.datatypes import MemoryUpdateMessages, she_bytes
from secure_hardware_extension.memory_update import MemoryUpdateProtocol
messages = MemoryUpdateMessages(
    auth_key=she_bytes.fromhex("000102030405060708090a0b0c0d0e0f"),
    m1=she_bytes.fromhex("00000000000000000000000000000141"),
    m2=she_bytes.fromhex(
        "2b111e2d93f486566bcbba1d7f7a9797c94643b050fc5d4d7de14cff682203c3"
    ),
)
update_protocol = MemoryUpdateProtocol(messages)

update_protocol.update_info.new_key
>>> b'\x0f\x0e\r\x0c\x0b\n\t\x08\x07\x06\x05\x04\x03\x02\x01\x0
```

## Sources

Accessed 26.07.2025.

[Autosar specification](https://www.autosar.org/fileadmin/standards/R22-11/FO/AUTOSAR_TR_SecureHardwareExtensions.pdf)

[NXP application note](https://www.nxp.com/docs/en/application-note/AN4234.pdf)

[Vector SHE Key Update Protocol](https://support.vector.com/sys_attachment.do?sys_id=534d25eb87548590b9f233770cbb3550)
fromless 0.0.2
A base class that prevents subclasses from being instantiated from an unqualified import.
Requires Python: >=3.9

# `fromless`

Create objects that ban unqualified imports.

## Example

In `demo.py`:

```python
from fromless import MustBeQualified   # note the irony

class Qualified(MustBeQualified):
    def __init__(self):
        super().__init__()
```

And at your REPL:

```python
>>> from demo import Qualified
>>> Qualified()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/Users/chrisjrn/src/goodbye_to_from/src/test.py", line 5, in __init__
    super().__init__()
  File "/Users/chrisjrn/src/goodbye_to_from/src/fromless/gtf.py", line 12, in __init__
    MustBeQualified._error_if_unqualified(traceback)
  File "/Users/chrisjrn/src/goodbye_to_from/src/fromless/gtf.py", line 42, in _error_if_unqualified
    raise Exception(f"Class {enclosing_class} was instantiated from an alias.")
Exception: Class Qualified was instantiated from an alias.
>>> import demo
>>> demo.Qualified()
<demo.Qualified object at 0x101509dc0>
```

Perfect.
catalyst-orm 0.0.1a2
catalyst is a typesafe python query builder
Requires Python: >=3.10

## ❗ this library is beyond highly experimental, dont use it please

# catalyst

a lightweight, sql-like query builder designed to accelerate python developers in handling database interactions. catalyst aims to simplify database operations, providing an intuitive and efficient approach to building and managing database queries in python.

## supported databases
currently, catalyst supports the following databases:
- ✅ postgres

support for additional databases is maybe planned in future updates.

## development

### requirements
- [uv](https://docs.astral.sh/uv) - a modern python package manager and build tool.

### environment setup
prepare your development environment with the following commands:

```bash
uv venv .venv --python 3.10
source .venv/bin/activate
uv sync
```

this creates and activates a virtual environment, then synchronizes all required dependencies.

### building catalyst
create distributable packages by running:

```bash
uv build
```

this generates build artifacts ready for distribution in **./dist**.

## roadmap
make this shit prod ready
tzk 0.5.1
Build tool for TiddlyWiki Zettelkasten
Requires Python: >=3.6

[![Documentation Status](https://readthedocs.org/projects/tzk/badge/?version=latest)](https://tzk.readthedocs.io/en/latest/?badge=latest)

**tzk** (*TiddlyZettelKasten*)
    is a TiddlyWiki edition and associated CLI
    for maintaining personal notes
    in something approaching the Zettelkasten method.
It’s updated periodically from whatever tooling I’m currently using
    [in my own thinking workspace](https://mosmu.se).
As such, it’s currently considered alpha-quality;
    while it ought to be very stable and there’s no meaningful risk of data loss,
    updating to a newer version might be difficult
    and I’m unlikely to accept patches
    unless they’re something I want for myself.
This is intended primarily as a nice starting platform
    on which to build your own tooling.

Some basic knowledge of [TiddlyWiki](https://tiddlywiki.com)
    is necessary and assumed.


Documentation / Installation
----------------------------

Find a live version of the edition on the web with further instructions
    at https://sobjornstad.github.io/tzk/.
You can find the documentation for the CLI
    (which handles creating the wiki,
     versioning with Git,
     and creating public and other derivative versions of the wiki)
    at https://tzk.readthedocs.io/en/latest/.


Video walkthrough
-----------------

Since tzk is still in an alpha state,
    general instructions on how to use it are somewhat lacking at the moment.
To fill in the gap in the meantime,
    I recorded an hour-long walkthrough showing how you might take notes using tzk;
    you can select individual sections to watch if that's longer than you want.
[Watch the video on YouTube](https://www.youtube.com/watch?v=9X_T-DVie8o).