semvec/pypi-packages huggingface dataset:
urbitob 0.0.4
A python implementation of urbit-ob
Requires Python: >=3.6

# urbit-pob

A python implementation of [urbit-ob](https://github.com/urbit/urbit-ob)

### Install

Run `pip install urbitob`

### Module Use

The library exposes two families of functions:

* `patp / patp_to_num / patp_to_hex / hex_to_patp / is_valid_patp`
* `patq / patq_to_num / patq_to_hex / hex_to_patq / is_valid_patq`

As well as:

* `clan`, for determining the ship class of a `@p` value
* `sein`, for determining the parent of a `@p` value
* `eq_patq`, for comparing `@q` values for equality
* `is_valid_pat`, for a faster/weaker check of `@p` or `@q`-ness that only
  validates syllables (and not proper dash formatting)

### Example Usage

```py
>>> import urbitob
>>> urbitob.patp(314159)
'~batdyr-topmun'
>>> urbitob.patp_to_num("~faster-pollen")
2077885931
>>> urbitob.hex_to_patq("EFFACED")
'~wisfes-batsed'
>>> urbitob.sein("~hashes-happen")
'~hattug'
>>> urbitob.clan("~marzod")
'star'
```

You could use it to generate list of Planets from a given Star:
```py
>>> v = urbitob.patq_to_hex("~sordem")
>>> planets = list(urbitob.hex_to_patp(hex(i)[2:]+v) for i in range(1,0xffff))
>>> planets[:10]
['~rigteg-havtuc', '~lonnub-navhet', '~risheb-difryc', '~sigren-daldux', '~rammel-malmyl', '~rapmes-ralres', '~boswex-ravret', '~sapper-loclut', '~talmep-sibsug', '~dalbur-todser']
```

### Testing

A simple `python -m unittest` will run the test suite.
charybdis 2.0.0
Tiny Hi-Rez API wrapper
Requires Python: >=3.10

# Charybdis
Tiny Hi-Rez API Python wrapper that I wrote to use in my Smite related projects
(and to play around with async).

Hi-Rez API documentation: https://webcdn.hirezstudios.com/hirez-studios/legal/smite-api-developer-guide.pdf

See the Hi-Rez API documentation for available methods and their parameters.
The structure of the returned values is not described though, so some work is
required to figure out what information can actually be obtained from the API.

Other Python wrappers:
* https://github.com/luissilva1044894/Pyrez
* https://github.com/DevilXD/aRez

## Installation
`pip install charybdis`

## Usage
### Sync
```python
import os

import charybdis

api = charybdis.Api(
    # These are also the default values.
    base_url=charybdis.Api.SMITE_PC_URL,
    dev_id=os.getenv("SMITE_DEV_ID"),
    auth_key=os.getenv("SMITE_AUTH_KEY"),
)

# Returns deserialized JSON.
scylla_skins = api.call_method(
    "getgodskins",  # Method name.
    "1988",  # God ID - Scylla.
    "1",  # Language ID - English.
)

for scylla_skin in scylla_skins:
    print(scylla_skin["skin_name"])

# Output:
# Standard Scylla
# Bewitching Bunny
# Child's Play
# COG Scylla
# and many more...
```
### Async
```python
import asyncio

import charybdis


async def main() -> None:
    async with charybdis.Api() as api:
        patch_info_task = asyncio.create_task(api.acall_method("getpatchinfo"))
        gods_task = asyncio.create_task(api.acall_method("getgods", "1"))

        patch_info = await patch_info_task
        gods = await gods_task

    newest_god = ""
    for god in gods:
        if god["latestGod"] == "y":
            newest_god = god["Name"]
            break

    print(
        f"The current patch is {patch_info['version_string']}"
        + f" and the newest god is {newest_god}."
    )


asyncio.run(main())

# Output:
# The current patch is 9.12 and the newest god is Maui.
```
dictpath_resolver 0.0.1
Provides a simple syntax to access nested JSON-like object in python.
Requires Python: >=3.6

# dictpath_resolver

[![PyPI Version][pypi-version]][pypi-url]
[![PyPI Downloads][pypi-downloads]][pypi-url]

[pypi-version]: https://img.shields.io/pypi/v/dictpath_resolver
[pypi-url]: https://pypi.org/project/dictpath_resolver/
[pypi-downloads]: https://img.shields.io/pypi/dm/dictpath_resolver

Provides a simple syntax to access nested JSON-like object in python.

## Syntax

The path should be a string, which consists of recurring patterns:

    Patern1Patern2Patern3......

There are 2 types of paterns:

- Dict member access patern: Starts with `.` then follows the member name. Member name must contain only `/a-zA-Z\d\-_/`.
- List item access patern: has an integer inside brackets `[]`.

Paterns are evaluated first, then applied recursively to current child object,
final value would be return when the list is exhausted.

Example:
```
object: {"building": {"floors": [{"name": "A"}, {"name": "B"}, {"name": "C"}]}}
path: ".building.floors[1].name"
resolved value: "B"
```

## Usage
```python
from dictpath_resolver import DictPathResolver

json_like = {"building": {"floors": [{"name": "A"}, {"name": "B"}, {"name": "C"}]}}
path = ".building.floors[1].name"
resolver = DictPathResolver(json_like, path)

print(resolver.is_resolvable())
# True
print(resolver.resolve())
# B

```
mwcomposerfromhell 0.5
Convert the parsed MediaWiki wikicode (using mwparserfromhell) to HTML.
Requires Python: >=3.7

mwcomposerfromhell
##################

.. image:: https://travis-ci.org/clokep/mwcomposerfromhell.svg?branch=master
    :target: https://travis-ci.org/clokep/mwcomposerfromhell

**mwcomposerfromhell** is a Python package that provides an easy-to-use method
to convert MediaWiki `Wikicode`_ to HTML via `mwparserfromhell`_. It supports
Python 3.

.. _Wikicode: https://en.wikipedia.org/wiki/Help:Wikitext
.. _mwparserfromhell: https://mwparserfromhell.readthedocs.io

Usage
-----

Normal usage is rather straightforward to convert from a ``str`` of Wikicode to
a ``str`` of HTML. It involves two steps:

1. Parse the Wikicode to an abstract syntax tree using ``mwparserfromhell``.
2. Convert the AST to HTML.

.. code-block:: python

    >>> import mwparserfromhell
    >>> import mwcomposerfromhell
    >>> wikicode = mwparserfromhell.parse(text)  # Step 1
    >>> html = mwcomposerfromhell.compose(wikicode)  # Step 2

You can also use it from the command line if you already have your wikicode in
a file. The convert HTML is output on standard out.

.. code-block:: sh

    python -m mwcomposerfromhell path/to/my/wikicode