semvec/pypi-packages huggingface dataset:
pycadf 4.0.1
CADF Library
Requires Python: >=3.9

======
PyCADF
======

.. image:: https://governance.openstack.org/tc/badges/pycadf.svg
    :target: https://governance.openstack.org/tc/reference/tags/index.html

.. Change things from this point on

.. image:: https://img.shields.io/pypi/v/pycadf.svg
    :target: https://pypi.org/project/pycadf/
    :alt: Latest Version

.. image:: https://img.shields.io/pypi/dm/pycadf.svg
    :target: https://pypi.org/project/pycadf/
    :alt: Downloads

This library provides an auditing data model based on the `Cloud Auditing Data
Federation <https://www.dmtf.org/standards/cadf>`_ specification, primarily for
use by OpenStack. The goal is to establish strict expectations about what
auditors can expect from audit notifications.

* `PyPi`_ - package installation
* `Online Documentation`_
* `Launchpad project`_ - release management
* `Blueprints`_ - feature specifications
* `Bugs`_ - issue tracking
* `Source`_

.. _PyPi: https://pypi.org/project/pycadf
.. _Online Documentation: https://docs.openstack.org/pycadf/latest/
.. _Launchpad project: https://launchpad.net/pycadf
.. _Blueprints: https://blueprints.launchpad.net/pycadf
.. _Bugs: https://bugs.launchpad.net/pycadf
.. _Source: https://opendev.org/openstack/pycadf
json-into-html 0.1.1
json2html is a Python library that fetches data from APIs, allows users to define the structure of the JSON response, and generates responsive HTML pages to display the data in a user-friendly format.
Requires Python: >=3.6


# json-into-html    [![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](https://choosealicense.com/licenses/mit/)

json-2-html is a Python library that fetches data from APIs, allows users to define the structure of the JSON response, and generates responsive HTML pages to display the data in a user-friendly format.




## classes

#### ApiHandler

```http
  This class is responsible for managing communication with the API and
  retrieving JSON data.

  It takes the API URL as input during initialization.

  The fetch_data method sends a GET request to the API and returns the JSON
  data.

  It includes error handling for timeouts, connection errors, HTTP errors, and
  invalid JSON responses.
```

#### JsonDefinition

```http
  This class is used to define the structure of the JSON data and how each
  field should be displayed.

  It uses an Enum called DisplayType to represent the different display types
  (text, image, video, etc.).

  The add_field method allows you to add a field definition, specifying the
  field name, display type, and any additional options.

  It includes validation to ensure that required options are provided for
  certain display types (e.g., width and height for images).
```

#### HtmlGenerator

```http
  This class generates the HTML code based on the JSON data and definitions
  provided.

  It uses the BeautifulSoup library to create and manipulate HTML elements.
  
  The generate_html method iterates over the data and definitions, calling the
  appropriate method to generate the HTML for each field.

  It includes methods for adding the HTML head (with title and CSS links), and
  for generating the HTML for different field types (text, image, video, file,
  link).

  It uses a templating engine (Jinja2) to separate the HTML code from the
  Python code, making it easier to maintain and modify the HTML structure.
```


## example.py

You can use this example code!

```python
from json-into-html import ApiHandler, HtmlGenerator, JsonDefinition, DisplayType

# API address
api_url = "https://dog.ceo/api/breeds/image/random"

api_handler = ApiHandler(api_url)

data = api_handler.fetch_data()

if data:
    json_definition = JsonDefinition()

    json_definition.add_field("message", DisplayType.IMAGE)
    json_definition.add_field("status", DisplayType.TEXT)

    html_generator = HtmlGenerator(data, json_definition)

    html = html_generator.generate_html()

    html_generator.save_html("dog_image.html")
    print("HTML generated successfully!")
else:
    print("Failed to fetch data from API.")```
ultoical 1.1.2
A web app allowing you to create an ical file from your Universite de Lorraine's timetable
Requires Python: >=3.10

# ULToICAL
[ [English](README.fr.md) | [Francais](README.fr.md) ]

[ [Support my work](https://ko-fi.com/totorocodesoften) ]

ULToICAL is an easy way to convert your Universite de Lorraine Multi timetable to an ICAL format to store in Google Agenda, Apple Calendars etc...
## Installation
To use ULToICAL you will need `python>=3.10`

### From PIP

Run `pip install ultoical`

To use the program run `ultoical`

### From source

Simply run

```bash
pip install .
```

And start the program using:

```bash
ultoical
```

## Getting the UL Token (optional)
To get the token simply go to your timetable inside the UL Multi app and press `CTRL + Maj + I`

Click on `network` on the window that just oppened

Change weeks on the timetable until you see a `200 POST schedule json`

Click on it, navigate to `Requests` and copy the `authToken` field

## TODO
- [ ] Official secure public instance
- [x] Automatic temp file deletion
- [x] Add french support
- [x] Better error handeling
- [x] Tokenless auth
fastapi-blueprint 1.0.2
A CLI tool to generate file structure for FastAPI projects.
Requires Python: >=3.6

FastAPI Blueprint
=================

.. image:: https://badge.fury.io/py/your-package-name.svg
    :target: https://pypi.org/project/fastapi-blueprint/

.. image:: https://static.pepy.tech/badge/fastapi-blueprint
    :target: https://pepy.tech/projects/fastapi-blueprint

FastAPI Blueprint is a command-line tool designed to help developers quickly generate a structured project file system for FastAPI applications. With this tool, you can jumpstart your FastAPI project with a clean, modular, and scalable architecture.

Features
--------

- Automatically generate directories and files for a standard FastAPI project.
- Includes support for:
  - ``routers``
  - ``models``
  - ``schemas``
  - ``services``
  - ``utils``
- Customizable templates to suit your project needs.
- Simple and intuitive CLI commands.

Installation
------------

To install FastAPI Blueprint, use pip:

.. code-block:: bash

    pip install fastapi-blueprint

Usage
-----

Generate a New Project Structure
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Run the following command to create a new FastAPI project:

.. code-block:: bash

    fastapi-blueprint init my_project

This will generate the following structure:

.. code-block:: text

    my_project/
    ├── app/
    │   ├── routers/
    │   ├── models/
    │   ├── schemas/
    │   ├── services/
    │   ├── utils/
    │   └── main.py
    └── requirements.txt

Adding Components
^^^^^^^^^^^^^^^^^

You can add individual components like routers or models:

.. code-block:: bash

    fastapi-blueprint add router users

This will create a new router file under the ``routers/`` directory.

Customize Templates
^^^^^^^^^^^^^^^^^^^

FastAPI Blueprint allows you to define your own templates for files and structures. Simply modify the default templates in the ``~/.fastapi-blueprint/templates/`` directory.

Contributing
------------

Contributions are welcome! If you'd like to contribute:

1. Fork the repository.
2. Create a feature branch: ``git checkout -b feature-name``
3. Commit your changes: ``git commit -m 'Add feature-name'``
4. Push to the branch: ``git push origin feature-name``
5. Open a pull request.

License
-------

This project is licensed under the MIT License. See the `LICENSE`_ file for more details.

Acknowledgments
---------------

FastAPI Blueprint is inspired by the simplicity and scalability of FastAPI itself. Thanks to the FastAPI community for building such an amazing framework!
hc-mcp-api-docs 2025.2.1
MCP server for our API documentation
Requires Python: >=3.10

# HC MCP API Docs

MCP server for our API documentation. This server provides tools to interact with our API documentation system.

## Features

- List available APIs grouped by environment
- Get detailed API information including documentation URLs
- Search APIs by title and description
- Generate code examples in TypeScript, Python, and cURL

## Configuration

The server can be configured using environment variables:

- `API_DOCS_BASE_URL`: Base URL for the API documentation.

## Tools

### list_apis
List our APIs grouped by environment. Returns titles, descriptions, accounts, and stages (max 100 APIs).

### get_api_details
Get API documentation URLs, environment details, and OpenAPI spec. Returns JSON/YAML/Swagger UI links.

### search_apis
Search APIs by title/description. Prioritizes title matches. Returns max 50 sorted results.

### generate_code
Generate API client code with endpoints and error handling. Supports TypeScript, Python, cURL.

## Installation

```bash
pip install hc-mcp-api-docs
```

## Usage

The server can be used with any MCP client. Example using the Claude desktop app:

1. Add the server to your MCP configuration
2. Use the available tools through the MCP interface

## Development

```bash
# Install dependencies
make prepare

# Build package
make build

# Upload to PyPI
make upload

# Install locally
make install

# Clean build artifacts
make clean