semvec/pypi-packages huggingface dataset:
pyqode-core 4.0.11
The core package contains the core components needed for writing a pyqode based
Requires Python: >=3.7
Keywords: CodeEdit,PyQt,editor,widget,qt

.. image:: https://raw.githubusercontent.com/pyQode/pyQode/master/media/pyqode-banner.png

About
-----


This is a fork of PyQode, which is now developed as the editor component for Rapunzel_ and OpenSesame_. The original PyQode repository (<= v2) is no longer maintained.

**pyqode.core** is the core framework of the `pyQode` project.

It contains the base classes and a set of extensions (modes/panels/managers)
needed to develop a specialised code editor.

It also provides a basic generic code editor that you can use as a fallback
when there is no specialised editor for a given language.

.. _OpenSesame: https://osdoc.cogsci.nl/
.. _Rapunzel: https://rapunzel.cogsci.nl/


License
-------

pyQode is licensed under the **MIT license**.


Requirements
------------

pyqode.core depends on the following libraries:

- Python 3 (>= 3.7)
- PyQt5 or PyQt6 or PySide
- pygments
- pyqode.qt
- future
- qtawesome (optional)
aparser-async-api 1.0.1
Asyncio is an alternative module for working with A-parser.
Requires Python: >=3.8

# aparser-async-api

Asyncio is an alternative [module api-python](https://github.com/a-parser/api-python) for working with A-parser.

- [aparser-async-api](#aparser-async-api)
  - [1. Dependencies](#1-dependencies)
  - [2. Implementation details](#2-implementation-details)
  - [3. Usage example](#3-usage-example)

## 1. Dependencies

- [`aiohttp` 3.8 or never](https://pypi.org/project/aiohttp/);
- [Python 3.7 or newer](https://www.python.org/).

## 2. Implementation details

Adaptation of synchronous code should require a minimum of effort.
All method names are identical to the original ones. The structure of the class is also similar to the original.

## 3. Usage example

```python
import asyncio

from aparser_async_api import AParser

APARSER_URL = '''your A-parser API URL'''
APARSER_PASS = '''your A-parser API password'''


async def main():
    task_id = 1
    api = AParser(APARSER_URL, APARSER_PASS)
    print(f'Ping: {await api.ping()}\n')
    print(f'A-parser Info: {await api.info()}\n')
    print(f'File link: {await api.getTaskResultsFile(task_id)}\n')
    print(f'Task state: {await api.getTaskState(task_id)}\n')
    print(f'Task config: {await api.getTaskConf(task_id)}\n')
    print(f'Task list: {await api.getTasksList()}')
    await api.close()  # Mandatory closure of the session `aiohttp.ClientSession` if you no longer need it


if __name__ == '__main__':
    asyncio.run(main())
```
wombatoo 1.0.0
A Data-Ops tool for devs
Requires Python: >=3.6

# WOMBATOO

#### Wombatoo is a python library which have the following features: 

1) Dataframe summary: Summary of dataframe in CSV format
2) Datacard: A single document having Timestamp, data owner, data source, data refresh cycle, data details, Intended use, data summary, ethical considerations, Recommendation and caveats. Some fields are pre-populated and the user can populate the rest to define a consice contract between data owner and data user.
3) Version: a local versioning tool using which a user can use to version small to medium datasets locally.
4) Report: A pandas-profiling report which can be saved in HTML, JSON and PDF formats.
5) Schema: A csv document having the schema of the dataset. Users can use it to validate the schema in the data pipeline. 

#### Installation

```
pip install wombatoo
```

```
from wombatoo import wombatoo
import pandas as pd

#reading df
df = pd.read_csv('base.csv')

if __name__ =="__main__":
    summary = wombatoo.metric_summary(df,path_to_save='summary.csv')
    datacard = wombatoo.datacard(df, path_to_save='Datacard_user.txt')
    version = wombatoo.version(df.head(5),file_name='fraud_bool', folder_path='./local_repo')
    report = wombatoo.generate_report(df=df.head(10), path_to_save='./Data_Profile_Report.html', pdf=False)
    schema = wombatoo.schema(df=df,path_to_save='schema.csv',show=1)
```
#### END
marcflow 0.3
A Python library for MARC data preprocessing
Requires Python: >=3.8

# Marcflow

Marcflow is a Python library for MARC (MAchine-Readable Cataloging) data
preprocessing. It can be used to extract data from records that meet specified
criteria and convert the data to JSON.

## General

```
marcflow.select(statement)
```

Specifies a scheme for parsing MARC records.

**statement** (*str*): field-expr [condition-expr]

- field-expr indicates the (sub)fields whose values will be
  extracted.
- condition-expr, if given, indicates the condition(s) that
  (sub)fields must satisfy to be selected.

Returns True if the parameter is a valid statement and False otherwise.

```
marcpick.marc(source)
```

Parses MARC records and extracts data based on specific criteria.

**source** (*str* | *TextIO*): one or more MARC records

Returns a generator that can be iterated over to obtain the extracted data.

## Installation

```
$ pip install marcflow
```

## Usage

```
>>> from marcflow import MarcFlow
>>> marcflow = MarcFlow()
>>> # The wildcard _ (Low Line) represents any single character in tags,
>>> # indicators and subfield codes.
>>> statement = 'LDR 001 010a 5__a (200__a\(?i\)java & !200__a\(?i\)script) \
... | 606__a^JAVA'
>>> marcflow.select(statement)
True
>>> with open('test.mrc', encoding='UTF-8') as fr:
...     data = marcflow.marc(fr)
...     next(data)
```