semvec/pypi-packages huggingface dataset:
pybasekit 1.0.2
Basic local database system
Keywords: python,db,database,storage


Do not use this for anything big as its not a secure way to store data.
This is meant to be used for fun and creating things for yourself or with a small group of people.

Example code:

import pybasekit

service = pybasekit.Start() # starts the service
NewDB = service.CreateDB("MyDatabase", "key") # creates a new database called MyDatabase and with the key "key"
db = service.ConnectDB("MyDatabase", "key") # Connects to the database using the same key
section = db.create_section("newsection") # Creates a section in the database to store data
collect = db.get_section_data("newsection") # Gets all data from section
print(collect) # prints the data from the section

Not all features were included in the example here are all the features:
    Start()/
        CreateDB(name, key)
        ConnectDB(name, key)/
            create_section(section_title)
            insert_data(section, Data_Title, Data_Value)
            insert_list(section, Data_Title, List)
            get_data(self, section, Data_Title)
            remove_data(section, Data_Title)
            update_data_value(section, Data_Title, New_Value)
            get_all_data()
            get_section_data(section)
ufc-api 0.0.1
A web crawler and parser for data on UFC fighters and events
Requires Python: >=3.7

# UFC API

UFC API is a lightweight web crawler built in Python to retrieve data on UFC fighters and events.

# Installation

You can install UFC API using pip:

```
pip install ufc_api
```

# Usage

Usage is simple. To get stats on a particular fighter returned as a json:

```
>>> from ufc-api import get_fighter

>>> get_fighter('Jon Jones')

>>> {'name': 'Jon Jones',
 'nickname': 'Bones',
 'nationality': 'United States',
 'birthplace': 'Rochester, New York',
 'birthdate': 'Jul 19, 1987',
 'age': '35',
 'height': '6\'4"',
 'weight': '248 lbs',
 'association': 'Jackson-Wink MMA',
 'weight_class': 'Heavyweight',
 'wins': {'total': '27',
  'ko/tko': '10',
  'submissions': '7',
  'decisions': '10',
  'others': '0'},
 'losses': {'total': '1',
  'ko/tko': '0',
  'submissions': '0',
  'decisions': '0',
  'others': '1'},
 'fights': [{'name': 'UFC 285 - Jones vs. Gane',
   'date': 'Mar / 04 / 2023',
   'url': 'https://www.sherdog.com/events/UFC-285-Jones-vs-Gane-95232',
   'result': 'win',
   'method': 'Submission (Guillotine Choke)',
   'referee': 'Marc Goddard',
   'round': '1',
   'time': '2:04',
   'opponent': 'Ciryl Gane'},
   ...
   
```

To get data on an event, the usage is similar:

```
>>> from ufc-api import get_event

>>> get_event('UFC 280')

>>> {'name': 'UFC 280: Oliveira vs. Makhachev',
 'date': '2022-10-22',
 'location': 'Yas Island/Yas West United Arab Emirates',
 'venue': 'Etihad Arena',
 'fights': [{'weightclass': 'Lightweight Title',
   'red corner': {'name': 'Charles Oliveira',
    'ranking': 'Unranked',
    'odds': '+165',
    'link': 'https://www.ufc.com/athlete/charles-oliveira',
    'result': 'Loss'},
   'blue corner': {'name': 'Islam Makhachev',
    'ranking': 'Unranked',
    'odds': '-195',
    'link': 'https://www.ufc.com/athlete/islam-makhachev',
    'result': 'Win'},
   'round': '2',
   'time': '3:16',
   'method': 'Submission'},
  {'weightclass': 'Bantamweight Title',
   'red corner': {'name': 'Aljamain Sterling',
    'ranking': 'Unranked',
    'odds': '-175',
    'link': 'https://www.ufc.com/athlete/aljamain-sterling',
    'result': 'Win'},
   'blue corner': {'name': 'TJ Dillashaw',
    'ranking': 'Unranked',
    'odds': '+150',
    'link': 'https://www.ufc.com/athlete/tj-dillashaw',
    'result': 'Loss'},
   'round': '2',
   'time': '3:44',
   'method': 'KO/TKO'},
  {'weightclass': 'Bantamweight',
   'red corner': {'name': 'Petr Yan',
    'ranking': 'Unranked',
    'odds': '-275',
    'link': 'https://www.ufc.com/athlete/petr-yan',
    'result': 'Loss'},
   'blue corner': {'name': "Sean O'Malley",
    'ranking': 'Unranked',
    'odds': '+230',
    'link': 'https://www.ufc.com/athlete/sean-omalley',
    'result': 'Win'},
   'round': '3',
   'time': '5:00',
   'method': 'Decision - Split'},
   ...

```
idealforms 0.0.14
Some charts I prepared earlier
Requires Python: >=3.9

# Ideal Forms
## "Some charts I prepared earlier."
Matplotlib charts formatted according to [The Data Visualization Catalogue](https://datavizcatalogue.com/).

## Install
```pip install idealforms```

## Bar
```python
from idealforms.bar import bar
from idealforms.formatters import money_formatter

categorical_data = dict(apples=500000,
                        oranges=1200000,
                        mangos=2200005)

fig, ax = bar(categorical_data,
              x_label='revenue',
              y_label='fruit',
              title='Fruit Revenue',
              formatter=money_formatter)
```
![ideal bar chart image](./docs/demo_fig.png)


## Pie
```python
import matplotlib.pyplot as plt
from idealforms.pie import pie
from collections import Counter
my_pi = "3.1415926535897"
pi_digits_count = Counter(str(my_pi).replace('.',''))

fig, ax = pie(
    pi_digits_count, 
    title='Py Pi Pie', 
    reverse_color_order=True,
    largest_color='xkcd:macaroni and cheese',
    figsize=(4,4)
)
plt.show()
```
![ideal pie chart image](./docs/demo_pie.png)
11x-wagtail-blog 0.2.0
11x Wagtail Blog
Requires Python: >=3.7
Keywords: wagtail,blog

11x Wagtail Blog
================

|PyPI| |Build| |Supported Python versions| |Documentation| |Downloads| 


11x Wagtail Blog
================

``11x-wagtail-blog`` is a wagtail app implementing basic blog features for a wagtail site. This project started as an
implementation of the blogging features of ``11x.engineering``, but since it is intended to be used as the first series
of articles, it has been open sourced and published here. It is intended to demonstrate how to develop a fully featured
package published to PyPI.


Quick Start
===========

To install::

    pip install 11x-wagtail-blog

Add ``x11x_wagtail_blog`` to your ``INSTALLED_APPS``::

    INSTALLED_APPS = [
        ...,
        'x11x_wagtail_blog',
        ...,
    ]

Since this package only gives you the common features of every blogging application, you will need to define your own page
models and derive them from `ExtensibleArticlePage`::

>>> from x11x_wagtail_blog.models import ExtensibleArticlePage
>>> from wagtail.admin.panels import FieldPanel
>>> from wagtail.blocks import TextBlock
>>> from wagtail.fields import StreamField

>>> class MyArticlePage(ExtensibleArticlePage):
...     body = StreamField([
...         ("text", TextBlock()),
...     ], use_json_field=True)
...
...     content_panels = ExtensibleArticlePage.with_body_panels([
...         FieldPanel("body"),
...     ])

This can be done in any valid Wagtail app.

Next, generate your migrations as usual::

    python manage.py makemigrations
    python manage.py migrate

You will have to define a template. The default template used is ``x11x_wagtail_blog/article_page.html``, but you should
override the ``get_template()`` method to return your own template.

.. code-block:: html

    <!DOCTYPE html>
    <html>
      <head>...</head>
      <body>
        <h1>{{ self.title }}</h1>

        {% include_block self.body %}

        <h2>About the authors</h2>
        {% for author in self.authors %}
        {% include "myblog/about_the_author_section.html" with author=author.value %}
        {% endfor %}

        <h2>Related Articles</h2>
        <ul>
        {% for article in self.related_articles %}
        <li><a href="{% pageurl article %}">{{ article.title }}</a></li>
        {% endfor %}
        </ul>
      </body>
    </html>


.. |PyPI| image:: https://img.shields.io/pypi/v/11x-wagtail-blog
   :target: https://pypi.org/project/11x-wagtail-blog/
.. |Build| image:: https://github.com/11x-engineering/11x-wagtail-blog/actions/workflows/package.yml/badge.svg
   :target: https://github.com/11x-engineering/11x-wagtail-blog/actions/workflows/package.yml
.. |Supported Python versions| image:: https://img.shields.io/pypi/pyversions/11x-wagtail-blog.svg
   :target: https://pypi.org/project/11x-wagtail-blog/
.. |Documentation| image:: https://readthedocs.org/projects/11x-wagtail-blog/badge/?version=latest
   :target: https://11x-wagtail-blog.readthedocs.io/en/latest/?badge=latest
.. |Downloads| image:: https://pepy.tech/badge/11x-wagtail-blog/month
   :target: https://pepy.tech/project/11x-wagtail-blog/
fastopendata-client 0.0.10
Client for the FastOpenData API service
Requires Python: >=3.7

FastOpenData Client
===================

The Python client for FastOpenData.

To use this client to retrieve data, you must have an API key. You can use the
client itself to get a free API key that's suitable for evaluation purposes:

```
>>> from fastopendata_client import FastOpenData
>>> api_key = FastOpenData.get_api_key('YOUR_EMAIL_ADDRESS')
```

Save your API key somewhere; you will use it each time you invoke the FastOpenData
client. If you lose your key, you can call this method again with the same
email address.

The free API key is rate limited and not suitable for production purposes. To
subscribe to the FastOpenData service and receive a key that will provide unlimited
access, please visit https://fastopendata.com. If you have questions about the
service or your particular use-case, email zac@fastopendata.com.

The main class for this client is `FastOpenData` which is invoked like so:

```
>>> from fastopendata_client import FastOpenData
>>> session = FastOpenData(api_key="<YOUR_API_KEY>")
>>> data = session.request(free_form_query="123 Main Street, Tallahassee, FL, 12345")
```

`data` now contains a dictionary with all the data from the FastOpenData server.

If you have a Pandas dataframe, you can append new columns containing data from
FastOpenData by calling `FastOpenData.append_to_dataframe` and specifying which
columns contain address information. For example, if `COLUMN_NAME` contains
unstructured address strings, you can do this:

```
>>> import pandas as pd
>>> from fastopendata_client import FastOpenData
>>> session = FastOpenData(api_key="<YOUR_API_KEY>")
>>> df = pd.DataFrame(...)
>>> session.append_to_dataframe(df, free_form_query=COLUMN_NAME)
```

Now `df` contains many new columns containing data from the FastOpenData server.

If your dataframe has columns containing structured address information, you
can do:

```
>>> session.append_to_dataframe(
        df,
        address1=ADDRESS1_COLUMN,
        address2=ADDRESS2_COLUMN,
        city=CITY_COLUMN,
        state=STATE_COLUMN,
        zip_code=ZIP_CODE_COLUMN
    )
```

Note that you have the option of specifying either `free_form_query` or the column names for structured address data, but not both. Doing so will raise an exception.