semvec/pypi-packages huggingface dataset:
fac-format 0.1.2
A deliberately complicated and inefficient file format alternative to JSON
Requires Python: >=3.7

# FAC Format - A Deliberately Complicated File Format

FAC (Frustratingly Awful Configuration) is an intentionally complicated and inefficient alternative to JSON. It's designed to be hard to read, write, and parse - because sometimes we need to appreciate how good we have it with JSON!

## Features

- ❌ Not human-readable (by design!)
- ❌ Unnecessarily complex syntax
- ❌ Deliberately verbose
- ✅ Python parser included
- ✅ Converts to/from Python dictionaries

## Installation

```bash
pip install fac-format
```

## Usage

### Writing FAC Files

```python
from fac_parser import FacWriter

data = {
    "name": "John Doe",
    "age": 30,
    "hobbies": ["reading", "coding"]
}

writer = FacWriter()
fac_content = writer.write(data)

with open('output.fac', 'w') as f:
    f.write(fac_content)
```

### Reading FAC Files

```python
from fac_parser import FacParser

with open('input.fac', 'r') as f:
    content = f.read()

parser = FacParser()
data = parser.parse(content)
```

## File Format Specification

FAC uses a unique and deliberately complicated syntax:

1. Files must start with `@begin/format@` and end with `@end/format@`
2. Comments use `\note` prefix
3. Values are declared using:
   ```
   @value|key_name
   /content\|type|value
   ```
4. Lists are declared using:
   ```
   @list|list_name
   |item\value1
   |item\value2
   /end\list
   ```
5. Objects are declared using:
   ```
   @object|object_name
   @value|nested_key
   /content\|type|value
   /end\object
   ```

### Data Types

- Text: `|text|value`
- Numbers: `|number|value`
- Booleans: `|boolean|true` or `|boolean|false`

## Example FAC File

```
@begin/format@
\note this is a sample FAC file

@value|name
/content\|text|John Doe

@value|age
/content\|number|30

@list|hobbies
|item\reading
|item\coding
/end\list

@object|address
@value|street
/content\|text|123 Main St
/end\object
@end/format@
```

## Why Use FAC?

You probably shouldn't! This format was created as a demonstration of how not to design a data format. It serves as an educational tool to appreciate the elegance and simplicity of formats like JSON, YAML, and TOML.

## Contributing

If you want to make FAC even worse (or better at being worse), feel free to contribute! Just remember: the more complicated and frustrating, the better.

## License

MIT License - Because even bad ideas should be free to share!
ossx 2.19.1.post1
aliyun oss sdk for python async
Requires Python: <4.0,>=3.8

# ossx

[![Coverage Status](https://coveralls.io/repos/github/sswest/ossx/badge.svg?branch=main)](https://coveralls.io/github/sswest/ossx?branch=main)
[![PyPI version](https://badge.fury.io/py/ossx.svg)](https://badge.fury.io/py/ossx)

ossx is an Aliyun OSS SDK for Python Asyncio.

You are free to extend this project, but it's recommended to always run the unit tests to ensure the existing functionality works as expected.

## Implementation Details

ossx uses `httpx` as the asynchronous http client, and makes the greatest effort to reuse `oss2` code. Therefore, the code of ossx itself is very small, and in addition, ossx also adds type annotations for public methods.

From the user's perspective, the use of ossx and oss2 should be very similar, in most cases you only need to add an `await`. Only when streaming reading Object, you need to call `await obj.read()` or asynchronous iteration `async for chunk in obj`.

**Please note, this library will monkey patch a small number of functions in the oss2 library, usually we believe this will not affect the independent use of the oss2 library, for details please see `ossx/patch.py`.**

## Compatibility

Starting from version 2.18.4, ossx will synchronize with the version numbers of the official Aliyun SDK in subsequent releases. When releasing new versions, OSSX will strive to achieve forward compatibility as much as possible. Currently, we guarantee that a minor version of OSSX can be compatible with lower versions of oss2.

It is recommended to keep the version numbers of ossx and oss2 consistent to reduce compatibility issues.

## Getting Started

### Installation

```bash
pip install ossx
```

### Usage

```python
import asyncio
from oss2 import Auth, models
from ossx import AsyncBucket

async def main():
    bucket = AsyncBucket(
        auth=Auth('your-access-key-id', 'your-access-key-secret'),
        endpoint='oss-cn-beijing.aliyuncs.com',
        bucket_name='your-bucket-name'
    )
    content = b'Hello, ossx!'
    await bucket.put_object('your-object-key', content)
    obj = await bucket.get_object('your-object-key')
    assert isinstance(obj, models.GetObjectResult)
    assert await obj.read() == content
    assert await obj.read() == b''

if __name__ == '__main__':
    asyncio.run(main())
```

You can find the API use cases currently supported in the `tests` directory.
urbani 0.1.4
URBAN-i API client library
Requires Python: >=3.6

# Urbani API Client Library

This is a client library for interacting with the URBAN-i API.

```shell
urbani/
│
├── urbani/
│   ├── __init__.py
│   ├── urbani.py
│
├── setup.py
└── README.md
```


## Installation

You can install the library using pip:

```shell

pip3 install urbani

```