semvec/pypi-packages huggingface dataset:
wscraping-helper 1.0.1
WebScraping helper module

# wscraping_helper
Python module origin github repository

## Command:

- get_html_data(): Querying html data from the URL address
- toString(): Returns the text of all the data in the array to another array.
- getAttributes(): Similar to the previous one. Returns the value of the given attributes of all the data of an array to another array.
- child_tags(): Returns tags within a given element according to criteria
regisoup 0.1.11
Convert <figure> and <xr> tags from deprecated MediaWiki extension to a new supported format.
Requires Python: >=3.7,<4.0

# **RegiSoup: Just Reg(Ex)ular and Beautiful Soup**
A tool to convert `<figure>` and `<xr>` tags from deprecated MediaWiki extension to a new supported format as specified in the extension `Figures` available on: 
[https://www.mediawiki.org/wiki/Extension:Figures](https://www.mediawiki.org/wiki/Extension:Figures).  

It was developed to mass modify pages via modifying the Wiki's `.xml` dump but it turns out that that is not a viable approach since `<text>` blocks inside the 
`.xml` dump are hashed with `sha1` and additionally have a size in bytes specified. It was simpler to create a MediaWiki API wrapper for `RegiSoup` so the original use case
for `RegiSoup` has translated [`StewChef`](https://pypi.org/project/stewchef/) but `RegiSoup` remains a standalone package.

## **Usage:**
Usage of `RegiSoup` is simple and easy. If at any point in time, you need a reminder of what anything means do not forget about:
```
regisoup --help
```
where a lot of information about the tool is gathered. Basic usage is as follows:
```
regisoup [input_file] [output_file]
```
`RegiSoup` should find and replace all `<figure>` and `<xr>` tags inside the input page. All the required information for the replacement MediaWiki parser functions is extracted from the existing tags or `RegiSoup` at least attempts to do so. One of the issues you may commonly run into is pages not specifying which page they are referencing. This can be quickly fixed by supplying the extra field for page title. For example:
```
regisoup [input_file] [output_file] 'Some Page Title'
```
**Note the use of quotation marks!** Another issue you can run into is captions being improperly specified. By default `RegiSoup` uses captions to generate the replacement parser functions. You can override this by supplying `--no-caption`. Some Wiki pages contain unescaped HTML characters, `RegiSoup` gets around this by doing a bit of encoding "magic". If this produces undesirable results you can try and supply the `--no-magic` flag and see if that works out better. Additionally for debugging support `RegiSoup` can be forced to not delete it's temporary files with `--no-clean-up` and be made more verbose with `--verbose`.
tagging-module 0.0.8
A lightweight rule based tech content tagging module for Python

# Tagging Module
A lightweight rule based tech content tagging module for Python

## Class Overview
The `TaggingService` class is designed to provide a tagging service. It uses the `tagging_system` module to assign tags to content based on predefined rules. The tagging rules are specified in a YAML file.

You may directly use it from this repo or install via Pip.
```
pip install tagging-module
```

## Constructor
### `__init__(self, rules_path: str = None)`
The constructor initializes a `TaggingService` object.

#### Parameters
- `rules_path` (optional): A string representing the path to the YAML file containing the tagging rules. If not provided, the default rules file path (`tagging_module/config/rules.yml`) is used.

#### Exceptions
- `FileNotFoundError`: Raised if the provided `rules_path` is not a valid file path.

### Example
```python
from tagging_module.tagging_service import TaggingService

# Using the default rules file path
service = TaggingService()

# Providing a custom rules file path
service = TaggingService(rules_path="path/to/custom_rules.yml")
```

## Methods
### assign_tags(self, content: str) -> List[str]
This method assigns tags to the provided content based on the defined tagging rules.

#### Parameters
- content: A string representing the content to be tagged.
#### Returns
A list of strings representing the assigned tags for the content.

### Example
```python
from tagging_module.tagging_service import TaggingService

# Assuming the rules file contains rules for tagging different types of content
service = TaggingService()

content = "This is a sample content."
tags = service.assign_tags(content)
print(tags)
# Output: ['sample', 'content']
```

Note: The output tags may vary based on the specific tagging rules defined in the rules file.
diffable-sql 0.2.0
Output normalised diffable database schemas
Requires Python: >=3.10,<4.0

# Diffable SQL

This is a small tool that outputs SQL from a number of databases in a sorted, diff-friendly order.

## Install

The tool supports any database [that SQLAlchemy supports](https://docs.sqlalchemy.org/en/20/dialects/index.html).
You must install the correct connector for your database:

```
$ pip install diffable-sql
$ pip install psycopg2-binary # postgres
$ pip install mysqlclient # mysql
```

## Usage

You can pass any number of DSNs as arguments, for example `postgresql:///db-name`. The tool will output normalised SQL
DDL statements for each DSN.

```shell
$ diffable-sql sqlite:///db.sqlite3
CREATE TABLE sometable (
	foo VARCHAR,
	id BIGINT NOT NULL
);

ALTER TABLE sometable ADD CONSTRAINT c PRIMARY KEY (id);
ALTER TABLE sometable ADD CONSTRAINT c UNIQUE (foo);
CREATE INDEX i ON sometable (foo);
```

Specifically:
- The tables and columns will be sorted by name
- Indexes and constraints will be renamed as `i` and `c`
- Deferrable constraint information will be hidden
- Identity columns will be hidden

These allow schemas to be more easily diffed.

## JSON output

Passing `--output-format=json` will output a json structure for each table, containing information on the column
types, SQL, nullability, indexes and constraints:

```shell
$ poetry run diffable-sql sqlite:///tools/db.sqlite3 --output-format=json | jq
```

Outputs:
```json
{
  "name": "sometable",
  "database": "tools/db.sqlite3",
  "columns": {
    "id": {
      "type": "BIGINT",
      "sql": "id BIGINT NOT NULL",
      "nullable": false
    },
    "foo": {
      "type": "VARCHAR",
      "sql": "foo VARCHAR",
      "nullable": true
    }
  },
  "indexes": [
    {
      "name": "foobar",
      "type": "Index",
      "sql": "CREATE INDEX foobar ON sometable (foo)",
      "columns": [
        "foo"
      ],
      "expressions": []
    }
  ],
  "constraints": [
    {
      "name": null,
      "type": "PrimaryKeyConstraint",
      "sql": "ALTER TABLE sometable ADD PRIMARY KEY (id)",
      "columns": [
        "id"
      ],
      "expression": null
    },
    {
      "name": null,
      "type": "UniqueConstraint",
      "sql": "ALTER TABLE sometable ADD UNIQUE (foo)",
      "columns": [
        "foo"
      ],
      "expression": null
    }
  ]
}
```

## Args

```console
$ diffable-sql --help
Usage: diffable-sql [OPTIONS] [dsn]...

Options:
  --no-rename-indexes TEXT        Don't rename indexes
  --no-rename-constraints TEXT    Don't rename constraints
  --no-ignore-deferrable-constraints TEXT
                                  Include deferrable constraint information
  --no-ignore-identity-columns TEXT
                                  Don't ignore identity column information
  --output-format [sql|json]
  --help                          Show this message and exit.

```
rmlab 0.4.4
RMLab python client
Requires Python: >=3.11

# RMLab Python Client

This client provides python bindings for RMLab services at **[rmlab.ai](https://rmlab.ai)**, available upon registration.

We offer *simulation* and *revenue optimization* services to airline companies.

**Simulation as a service:**

* Unlimited number of competing carriers.

* Massively parallel simulations on arbitrarily big flight markets.

* Statistical sampling for modelling customers behavior, sensible to seasonality and events.

* Validation of pricing algorithms given demand patterns before deploying to production.


**Revenue optimization as a service:**

* Process arbitrarily large sets of historic data.

* Run state-of-the-art algorithms for forecasting and optimization.

* Fine-grain optimization per flight level.

* AI-based adaptive forecasters & optimizers operating on nightly runs.


**Server infrastructure characteristics:**

* World-wide availability hosted in **[Google Cloud Platform](https://cloud.google.com)**.

* Data scalability across high-performance in-memory storage servers.

* Per-customer fully isolated compute and data environments.

* End-to-end TLS encryption (optional IPsec access).