semvec/pypi-packages huggingface dataset:
fastertags 0.2024.10
A small example package
Requires Python: >=3.12

# fastertags, an HTML tag library

A typesafe library for writing HTML in Python:

```
import fastertags as h

if __name__ == "__main__":
    doc = h.html(
        h.head(
            h.title("An example document"),
        ),
        h.body(
            h.h1("Title"),
            h.p(class_="css-class-name")("some paragraph"),
            h.p("Some more paragraph"),
        ),
    )
    print(doc)
```

yields

```
<!DOCTYPE html><html><head><title>An example document</title></head><body><h1>Title</h1><p class="css-class-name">some paragraph</p><p>Some more paragraph</p></body></html>
```

Tags and Attributes are scraped from the WHATWG HTML Spec
at [https://html.spec.whatwg.org/](https://html.spec.whatwg.org/).  Version numbers reflect when the scraping was done,
the current version `0.2024.10` was taken in October 2024.

## HTMX

`fastertags` is a standalone building block for `fasterhtml`, which in turn uses HTMX.  Most notably, `fastertags`
serializes event-handler `on*` attributes as `hx-on:*`, for example `hx-on:click` instead of `onclick`.

This can be changed by setting `HTMLElement.EVENT_HANDLER_PREFIX`:

```
doc = h.h1().on("click", "alert('clicked')")("Title")

print(doc)
# <h1 hx-on:click="alert('clicked')">Title</h1>

h.HTMLElement.EVENT_HANDLER_PREFIX= "on"

print(doc)
# <h1 onclick="alert('clicked')">Title</h1>
```

## Scoped CSS

`fastertags` emulates the `scoped` attributes on `<style>` tags by wrapping its contents in `@scope { ... }`.
The `h.style()` function does feature the boolean attribute `scoped` that allows for `True`, `False`, or `None`.
The default is `None`, which means contents will be wrapped in `@scope { ... }` if the element is not serialized
as the child of a `head` element:

```
doc = h.html(
    h.head(
        h.style("not scoped"),
    ),
    h.body(
        h.style("scoped"),
    ),
)
print(doc)
```

yields

```
<!DOCTYPE html><html><head><style>not scoped</style></head><body><style>@scope {scoped}</style></body></html>
```
pycaruna 1.0.3
Caruna API Python implementation
Requires Python: >=3.8

﻿# pycaruna

[![PyPI version](https://badge.fury.io/py/pycaruna.svg)](https://badge.fury.io/py/pycaruna)

Basic Python implementation for interfacing with Caruna Plus (sometimes called _Caruna+_). It supports only basic 
methods, but enough to extract electricity usage data for further processing.

Supported features:

* Get user profile information
* Get metering points ("assets")
* Get consumption data (daily/hourly)

## Usage

The project is published on PyPI: https://pypi.org/project/pycaruna/ . You can use this package by adding the 
following to your `requirements.txt`:

```
pycaruna
```

The `examples/` directory has example Python programs illustrating how to use the library.

The `resources/` directory has examples of API response structures.

## Caveats

* During daylight savings time changes, the API may return a duplicate datapoint (same timestamp in two consecutive 
  data points). See https://github.com/Jalle19/pycaruna/issues/7 for more details.
* The authentication procedure requires a lot of HTTP requests to be sent back and forth, so the process is 
  relatively slow. It's best to store and reuse the token produced by it instead of doing the authentication 
  process all over again all the time.

## Related projects

* [caruna-influxdb](https://github.com/Jalle19/caruna-influxdb) - a collection of scripts for ingesting your Caruna data 
into InfluxDB

## Credits

https://github.com/kimmolinna/pycaruna

## License

MIT
GammaJ 6
A small lightweight language that combines Python and HTML.
Requires Python: >=3.12


A small lightweight language that combines Python and HTML.
Recommended file extension: .γ/.gmaj

Example syntax:
```GammaJ
export <void> <!DOCTYPE html> </void> # recommended to use at the top of your file

# comment
x: int = 123; # variable
# semicolon is optional
def xyz() -> None { # opening brace
    ... # ellipsis (ignores the line)
} # closing brace

def main() -> None {
    # to insert html, use the 'export html' statement along with a 'end html' as shown below
    export <void>
        <!-- html code here -->
        <h1>
            Hello, world!
        </h1> <!-- this will open your browser to a random unused port with a 'Hello, world' heading -->
    </void>
    
    # after the closing 'html' tag, you can continue with python code
    # to export for ex. a python variable, which is not possible with 'export gamma',
    # you can use plain 'export' instead:
    name: str = "Bob"
    export print("Unformatted", "text") # creates plain text
    export paragraph("Hello,", name) # creates a paragraph with text: 'Hello, Bob'
    export heading1("Heading 1") # \
    export heading2("Heading 2") # |
    export heading3("Heading 3") #  > headings
    export heading4("Heading 4") # |
    export heading1("Heading 1") # /
    export weblink("https://google.com", "Google") # creates a hyperlink. param 1 is href
    export image("cat.png", "A picture of a munchkin cat") # creates an image. param 1 is src, param 2 is alt
    export list("item 1", "item 2", "item3") # creates an unordered list. cannot be created with brackets [] (e.g. export ["1", "2"]) like non-exported lists
    export table("item 1", "item 2", "item") # creates a table
    
if __name__ == '__main__' { # runs only when the file is executed directly
    main() # executes the main function
}
```

DISCLAIMER: The

DISCLAIMER: You cannot import GammaJ files in Python files or from other GammaJ files.
            You _can_ import Python from GammaJ files though.

## Running a GammaJ file
### Method 1: Use cmdlet (recommended)
```commandline
gammaj <filename>
```
### Method 2: Run using python module
```commandline
python -m gammaj <filename>
```

## How to get Syntax Highlighting (new in v4)
- Disclaimer: Right now, syntax highlighting is only available for PyCharm (all editions including the free community edition)
- Download GammaJ.xml [here](https://github.com/elemenom/gammaj/blob/main/GammaJ.xml)
- Click 'Download raw file'
- Move the downloaded file (usually in C:/Users/<USERNAME>/Downloads) to your PyCharm 'filetypes' directory (usually C:/Users/<USERNAME>/AppData/Roaming/JetBrains/PyCharm<VERSION>/filetypes)
- Restart PyCharm (if needed)
- Voilà! You now have colour in your GammaJ file.
custom-telegraph 0.1.0
A library adds dots annotation to telegraph library
Requires Python: >=3.7

# Custom telegraph library docs 

A Python library for working with the [Telegraph API](https://telegra.ph/).

Custom telegraph library uses data class instead of dicts to show telegraph api data 
**Note:** This is my first library, so if you find bugs, please don't kill me

- __from custom_telegraph import Telegraph__ to get main object
- __from custom_telegraph.types import *__ to get types

## Installation

You can install the package using `pip`:
```bash
pip install custom_telegraph
```


## Usage
Importing the Main Object
To get started, import the main Telegraph object:
```python
from custom_telegraph import Telegraph
```


Importing Types
If you need access to custom types:

```python
from custom_telegraph.types import *
```