semvec/pypi-packages huggingface dataset:
autoschedule 1.0
Generate schedule, talks, speakers page automatically like official Pycon thailand 2019 website: https://th.pycon.org
License: MIT
Keywords: autoschedule,schedule,generator,codegenerator,schedulepage,talks,talkspage,speakers,speakerspage,pycon

# autoschedule by Chomtana

Generate schedule, talks, speakers page automatically like official Pycon thailand 2019 website: https://th.pycon.org

* Schedule Page: https://th.pycon.org/schedule
* Talks Page: https://th.pycon.org/talks
* Speakers Page: https://th.pycon.org/speakers

These three pages generated from one yaml file: [CLICK HERE FOR YAML FILE EXAMPLE (talks2019.yaml)](https://github.com/Chomtana/autoschedule/blob/master/talks2019.yaml "talks2019.yaml")

And these three pages are linked together

Good for people who organizing conference event and don't want to code your website schedule, talks, speakers page

# How to use

## For local file generation use

### Basic example
```python
from autoschedule import generate

generate("talks2019.yaml")
```

*Note: you need to change **talks2019.yaml** to your correct yaml file path*

### Custom file name
```python
from autoschedule import generate

generate("talks2019.yaml", schedule_page="./timetable.html", talks_page="./courses.html", speakers_page="./tutors.html")
```

*Note: you need to change **talks2019.yaml** to your correct yaml file path*

## For using in nikola

### Step 1: Install ScheduleShortcode plugins

Copy [ScheduleShortcode.py](https://github.com/Chomtana/autoschedule/blob/master/ScheduleShortcode.py) and [ScheduleShortcode.plugin](https://github.com/Chomtana/autoschedule/blob/master/ScheduleShortcode.plugin) from this repository to plugins/schedule folder in your nikola setup

*Note: if folder doesn't exists, create new one*

### Step 2: Use shortcode in your page

Paste:
* `{{% schedule mode="schedule" file="../talks2019.yaml" talks_page="/talks" speakers_page="/speakers" schedule_page="/schedule %}}` To your schedule page
* `{{% schedule mode="talks" file="../talks2019.yaml" talks_page="/talks" speakers_page="/speakers" schedule_page="/schedule %}}` To your talks page
* `{{% schedule mode="speakers" file="../talks2019.yaml" talks_page="/talks" speakers_page="/speakers" schedule_page="/schedule %}}` To your speakers page

*Note: you need to change **../talks2019.yaml** to your correct yaml file path*

Example of these step can be found in [here](https://github.com/Chomtana/autoschedule/tree/master/nikolaexample)
julialg 0.1.0
Julia-style arrays in Python
License: MIT

# `julialg`
_Julia-style arrays in Python_

Python library for mimicking Julia LinearAlgebra array indexing style and display formatting.

Test Result: [![CircleCI](https://circleci.com/gh/JWKennington/julialg/tree/master.svg?style=svg)](https://circleci.com/gh/JWKennington/julialg/tree/master)


## Motivation and Summary
Julia's `LinearAlgebra` package has some nice features, some of which are easier to emulate in Python than others. When 
comparing the results of Python code vs Julia code, it is annoying to have to mentally switch between the 0-indexed nature of 
Python and the 1-indexed nature of Julia. Also, the Julia arrays have a prettier array.

This package wraps numpy n-dimensional arrays in a new class, `JulArray`, and allows for 1-indexed slicing (more mathematically intuitive) 
instead of 0-indexed slicing (computer science convention). Also improves the prettiness of the representation of the 
array in a manner similar to Julia's LinearAlgebra package. To be clear, this is a Python package, meant to bring some 
of the elegance of Julia's interface for tensors to the Python setting


## Indexing
The `JulArray` class wraps a `numpy.ndarray` but overrides the getitem syntax to allow for 1-indexed style instead of
the default 0-indexed style. For example:
```python
>>> import numpy, julialg

# Create a numpy array
>>> a = numpy.arange(1, 11).reshape((2, 5))

# Create a JulArray from the numpy array
>>> j = julialg.JulArray(a)

# Index the numpy array using 0-indexed syntax
>>> a[0, 0:2]
array([1, 2])

# Index the JulArray using 1-indexed syntax
>>> j[1, 1:3].array
array([1, 2])
```

Notice in the above sample that the `JulArray` is able to convert both ints and slices from 1-indexed notation to
0-indexed notation to produce the same underlying numpy array. 

## Display
The `JulArray` overrides the default representation of the numpy array to be more cleanly formatted (like Julia arrays).
```python
>>> julialg.JulArray(numpy.arange(1.0, 11.0).reshape((2, 5)))
2x5 Array{float64,2}
  1.0000     6.0000
  2.0000     7.0000
  3.0000     8.0000
  4.0000     9.0000
  5.0000    10.0000
```
httpio 0.3.0
HTTP resources as random-access file-like objects
License: MIT

httpio
======

HTTP resources as random-access file-like objects

httpio is a small Python library that allows you to access files
served over HTTP as file-like_ objects (which is to say that they
support the interface of the standard library's BufferedIOBase_
class). It differs from libraries like ``urllib`` and ``requests`` in
that it supports ``seek()`` (which moves an internal pointer), and
that ``read()`` makes a request with the ``Range`` header set. It also
supports caching of contents using a configurable block size, and will
reuse TCP connections where possible.

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

Use ``pip`` to install httpio:

.. code-block:: console

    $ pip install httpio

Usage
-----

.. code-block:: python

    import zipfile
    import httpio

    url = "http://some/large/file.zip"
    with httpio.open(url) as fp:
        zf = zipfile.ZipFile(fp)
        print(zf.namelist())

.. _file-like: https://docs.python.org/3/glossary.html#term-file-object

.. _BufferedIOBase: https://docs.python.org/3/library/io.html#io.BufferedIOBase

Unit Tests
----------

Unit tests are provided for the standard behaviours implemented by
the library. They can be run with

.. code-block:: console
    
    $ python -m unittest discover -s tests

or a ``tox.ini`` file is provided which allows the tests to be run in
virtual environments using the ``tox`` tool:

.. code-block:: console
    
    $ tox
well-schematics 0.2.0
matplotlib code for drawing borehole schematic diagrams
License: MIT
Keywords: groundwater data

# well-schematics

[![Open Source Love svg2](https://badges.frapsoft.com/os/v2/open-source.svg?v=103)](https://github.com/kinverarity1/well-schematics/blob/master/LICENSE)
[![PyPI pyversions](https://img.shields.io/pypi/pyversions/python-sa-gwdata.svg)](https://pypi.python.org/pypi/well-schematics/)
[![PyPI version shields.io](https://img.shields.io/pypi/v/python-sa-gwdata.svg)](https://pypi.python.org/pypi/well-schematics/)
[![Documentation Status](https://readthedocs.org/projects/python-sa-gwdata/badge/?version=latest)](http://well-schematics.readthedocs.io/?badge=latest)

matplotlib code for drawing borehole/well schematic diagrams

## Install

```bash
$ pip install -U well-schematics
```

## Usage

Check out the [documentation](http://well-schematics.readthedocs.io/?badge=latest).

```python
>>> from well_schematics import draw_simple
>>> draw_simple(pzone_top=27, pzone_bottom=36, casing_top=-0.5, pzone_type="S")
```

![](example.png)

## Contributing / roadmap

I would love to have implementations of different types of schematics. Any 
contributions at all are [welcome](https://github.com/Unidata/MetPy#contributing)!

- <strike>The simplest well: casing with a production zone at the bottom</strike>
- Different types of production zones, particularly perforations
- Multiple production zones separated by blanks
- Different pipe diameters
- Risers (pipe inside pipe)
- Drilled hole
- Cemented zones outside pipe
- Cement plugs
- Annotations tied to each casing pipe/production zone

## License

Free to modify and re-distribute under the [MIT license](LICENSE).