semvec/pypi-packages huggingface dataset:
pidgy 2023.4.20
literate computing in python
Requires Python: >=3.7

# `pidgy` literate computing interface

![pidgy logo](pidgy.png "PIDGY written in large lower case sans serif text with the word WEAVE written in capital letters underneath the letters PID")

`pidgy` is a fun, literate and interactive style of programming in markdown & python. together, these languages offer an exciting new experience to rapidly co-develop of code and narrative in Jupyter computational notebooks.

## writing with `pidgy`

<figure markdown>

```bash
pip install pidgy
```
<figcaption>install <code>pidgy</code> with `pip`</figcaption>
</figure>


<figure markdown>

```ipython
%reload_ext pidgy
```
<figcaption markdown>

1. 🪐 open a jupyter notebook
2. 🔌 activate the <code>pidgy</code> extension
3. ✏️ program in markdown
 
</figcaption> 
</figure>

<figure markdown>

<figcaption markdown style="font-size: 1.5rem;">

[💡 try `pidgy` in jupyterlite without any installation][pidgy lite][^lite] 

</figcaption>
</figure>

## programming in markdown

markdown is inclusive AF![^a11y] it is a plain-text format that never fails [^violate].
further markdown can include any programming language within its contents.
effectively, markdown files are literate programs that really on code and narrative to cooperate. markdown is a global minimum for teams of people with different language literacies.

a <kbd>Tab</kbd> separates markdown code and narrative, `pidgy` uses this nearness to create python representations of the markdown. with code and narrative so close, an author can fluidly switch between the writing modes capturing more of their process.

## learn more

* [try `pidgy`, without installing it, in `jupyterlite`.][pidgy lite]
* learn more from the `pidgy` documentation.
* [learn how CommonMark markdown converts to python][midgy]
* [contributing and development]

## development

[midgy]: https://github.com/deathbeds/midgy "midgy tangles markdown to python from pidgy"
[pip]: https://pypi.org/ "python package index"
[improving accessibility of markdown]: https://www.smashingmagazine.com/2021/09/improving-accessibility-of-markdown/
[With Markdown, Even the Blind Can Write]: https://tidbits.com/2013/06/18/with-markdown-even-the-blind-can-write/
[pidgy lite]: https://deathbeds.github.io/pidgy/run/
[jupyterlite]: https://github.com/jupyterlite/jupyterlite
[contributing and development]: #

[^a11y]: there are techniques for [improving accessibility of markdown] and abiding best practices.
[^violate]: markdown WILL violate expectation through implementation inconsistencies. over time we learn to navigate the nuances across products.
[^lite]: [jupyterlite] is a new in-the-browser jupyter experience that requires zero installation.
my-pipeline-package 1.1.25
Build package from python tests.

# DevOps Homework

Welcome to the Postscript DevOps take home task! This task should take you an hour or less to complete. You will be working with a simplified service with a minimal feature set.

## Background

At Postscript, we run a link shortening microservice that converts long URLs into short URLs (like an in-house [Bitly](https://bitly.com/)). To shorten links, we take the numeric identifier of the link and encode it using the [Base62 encoding scheme](https://en.wikipedia.org/wiki/Base62).

This microservice is a simplified version of the encoding and decoding logic our link shortener uses. The service exposes two endpoints, `encode` and `decode`, as part of its API that another service could use to implement the link shortening logic.

## Requirements

As the next step to get this microservice into production, you are working on implementing a CI/CD pipeline to test and "deploy" the service as a Docker container. Your goal is to accomplish the following with your pipeline:

1. Test the application code on each commit and pull request using Github Actions
  - Tests are written in `test_app.py` and run with [Pytest](https://pypi.org/project/pytest/)
2. Implement the `decode` function in `app.py`.
  - There are tests in `test_app.py` that can help you validate your solution.
  - Feel free to add additional tests as well.
3. Build a container image that runs the application as part of the CI pipeline.
  - A `Dockerfile` is included to use as a starting point or inspiration.
  - The container should run without errors and work as reasonably expected.
4. Publish the container image to a container registry.
  - Any container registry (Github Packages, ECR, Dockerhub, etc.) is OK.
  - If you cannot integrate with a live container registry due to cost, authentication, or other constraints, that's OK- comment out the uploading step of your pipeline and explain how it works instead.

You can change any of the code in the application, the tests, or the `Dockerfile` at your discretion. You can use any tools or resources you'd like to help you accomplish this task.

At the end of the task, please summarize your experience in `summary.md`. Outline the steps you took and how you solved problems as they came up.
pydillo 0.2.2
Common Dillo Development Module
Requires Python: >=3.6

# PyDillo

### Local

```
export PYTHONPATH=/path/to/pydillo:$PYTHONPATH
```

### Docker

0. Buid local **development** docker image

```
bash development.sh
```

1. Run **development** image with local source

```
sudo docker run \
  -it \
  --name pydillo --rm \
  -v /home/ermiry/Documents/Work/pydillo:/home/pydillo \
  itdillo/pydillo:development /bin/bash
```

2. Handle **pydillo** module

```
export PYTHONPATH=$pwd:$PYTHONPATH
```