semvec/pypi-packages huggingface dataset:
construct 2.10.70
A powerful declarative symmetric parser/builder for binary data
License: MIT
Requires Python: >=3.6
Keywords: construct,kaitai,declarative,data structure,struct,binary,symmetric,parser,builder,parsing,building,pack,unpack,packer,unpacker

Construct 2.10
===================

Construct is a powerful **declarative** and **symmetrical** parser and builder for binary data.

Instead of writing *imperative code* to parse a piece of data, you declaratively define a *data structure* that describes your data. As this data structure is not code, you can use it in one direction to *parse* data into Pythonic objects, and in the other direction, to *build* objects into binary data.

The library provides both simple, atomic constructs (such as integers of various sizes), as well as composite ones which allow you form hierarchical and sequential structures of increasing complexity. Construct features **bit and byte granularity**, easy debugging and testing, an **easy-to-extend subclass system**, and lots of primitive constructs to make your work easier:

* Fields: raw bytes or numerical types
* Structs and Sequences: combine simpler constructs into more complex ones
* Bitwise: splitting bytes into bit-grained fields
* Adapters: change how data is represented
* Arrays/Ranges: duplicate constructs
* Meta-constructs: use the context (history) to compute the size of data
* If/Switch: branch the computational path based on the context
* On-demand (lazy) parsing: read and parse only what you require
* Pointers: jump from here to there in the data stream
* Tunneling: prefix data with a byte count or compress it


Example
---------

A ``Struct`` is a collection of ordered, named fields::

    >>> format = Struct(
    ...     "signature" / Const(b"BMP"),
    ...     "width" / Int8ub,
    ...     "height" / Int8ub,
    ...     "pixels" / Array(this.width * this.height, Byte),
    ... )
    >>> format.build(dict(width=3,height=2,pixels=[7,8,9,11,12,13]))
    b'BMP\x03\x02\x07\x08\t\x0b\x0c\r'
    >>> format.parse(b'BMP\x03\x02\x07\x08\t\x0b\x0c\r')
    Container(signature=b'BMP')(width=3)(height=2)(pixels=[7, 8, 9, 11, 12, 13])

A ``Sequence`` is a collection of ordered fields, and differs from ``Array`` and ``GreedyRange`` in that those two are homogenous::

    >>> format = Sequence(PascalString(Byte, "utf8"), GreedyRange(Byte))
    >>> format.build([u"lalaland", [255,1,2]])
    b'\nlalaland\xff\x01\x02'
    >>> format.parse(b"\x004361789432197")
    ['', [52, 51, 54, 49, 55, 56, 57, 52, 51, 50, 49, 57, 55]]
gptq-api 0.0.3
OpenAI compatible API server for AutoGPTQ model
License: MIT
Requires Python: >=2.7

# GPTQAPI Server

LLM API server for AutoGPTQ model. This server is designed to be compatible with the OpenAI API, allowing you to seamlessly use OpenAI clients with it.

## Installation

Before you can run the server, you need to install the necessary package. You can do this easily with `pip`:

```bash
pip install gptq-api
```

## Usage

To run the GPTQAPI Server, use the following command:

```bash
python -m gptqapi.server [model-name] [port]
```

The `model-name` argument is mandatory while the `port` argument is optional, if not provided, it will use 8000 as the default.

You can also configure the server using a `.env` file for convenience. Here's an example:

```dotenv
# .env file
MODEL_NAME=robinsyihab/Sidrap-7B-v2-GPTQ
PORT=8000
WORKERS=1
SYSTEM_PROMPT=
```

This `.env` file sets default values for the model name, the port the server will listen on, the number of worker processes, and the system prompt which can be used to customize behavior.

## API Schema

This server follows the OpenAI API schema, allowing for seamless integration with OpenAPI client libraries. You can utilize all typical endpoints as if you were using the actual OpenAI API, making it easier to integrate into your existing infrastructure if you're familiar with the OpenAI platform.

## Environment Variables

Here is a list of environment variables you can use to configure the server:

- `MODEL_NAME`: (required) Identifies which AutoGPTQ model to use.
- `PORT`: (optional) Specifies the port number on which to run the API server.
- `WORKERS`: (optional) Defines the number of worker processes for handling requests.
- `SYSTEM_PROMPT`: (optional) Sets the system prompt for the model if needed.

[] Robin Syihab ([@anvie](https://x.com/anvie))
screenplain 0.11.1
Convert text file to viewable screenplay.
License: MIT

About Screenplain
=================

You're a hacker. The command line is your home. You know tools like grep, sed
and Git inside out. You have formed a symbiotic relationship with your text
editor. Those tools are powerful in the right hands. But you're also a
screenwriter. Screenwriting is much like programming. It's about structure and
form, and -- obviously -- about reading, writing and modifying huge amounts of
text. You don't want to use software that lacks the power of your hacking
tools just because you're writing a screenplay instead of a shell script.

Enter Screenplain.

Screenplain allows you to write a screenplay as a plain text file using
a format called [Fountain](http://fountain.io). Text files
are simple and supported by all text manipulation software. It's not just for
hackers, too. The simplicity of plain text allows you to easily view and edit
them on devices such as tablets and phones. No need for specific screenwriting
software.

The magic that Screenplain performs is to take your plain text file and
convert it to a good looking screenplay in an industry standard format.
Send that file off to your producer, agent, director or screenwriting
competition. The supported output formats are FDX  HTML, and PDF.

Screenplain can be used as a command-line application or a library.
An [Online version of Screenplain](http://www.screenplain.com) is also
available.

Note that Screenplain is under development and is missing features and
the master branch may not always work. I'm currently working on supporting
the whole [Fountain](http://fountain.io) specification. (Fountain
was previously known as "Screenplay Markdown" or "SPMD.")

Installing
==========

    pip install screenplain

To enable PDF output, install with the PDF extra (installs ReportLab):

    pip install 'screenplain[PDF]'

Credits
=======

Screenplain was coded by [Martin Vilcans](http://www.librador.com).

The CSS code that formats Screenplain's HTML output as something that
looks as much as a printed screenplay as is possible in HTML was
created by [Jonathan Poritsky](http://www.candlerblog.com/).

The [Fountain](http://fountain.io) file format is the result of a
collaboration between [Stu Maschwitz](http://prolost.com) and
[John August](http://johnaugust.com/).


License
=======

Screenplain is released under the [MIT license](http://www.opensource.org/licenses/mit-license.php).


Developing
==========

Set up virtual environment:

    python3 -m venv .venv
    . .venv/bin/activate
    pip install -r requirements.txt
    pip install -e .

After this, the `screenplain` command will use the working copy of your code.

To run unit tests and style checks, run:

    bin/test
python-sonycisip2 0.2.5
A Python package for Sony CISIP 2
License: MIT
Requires Python: >=3.6.0


# python_sonycisip2
Python library to interface with Sony's CISIP2 Protocol

```
python_sonycisip2
├─ LICENSE
├─ README.md
├─ setup.py
└─ src
   └─ python_sonycisip2
      ├─ commandset.py
      ├─ python_sonycisip2.py
      ├─ variables.py
      └─ __init__.py

```