Saravanan666/pypi-org huggingface dataset:
Package: woodchips
WoodchipsThe cutest little logger you've ever seen.Aren't logs just a bunch of woodchips?Woodchips was created to be the cutest little logger you've ever seen. I wanted something dead simple and reusable as I found myself using the same logging setup over and over in projects. Woodchips gives you everything you need to setup the Python logging library in your project, all without the need to import or call on theloggingpackage, know the various syntaxes for setting up handlers and formatters, etc which makes logging with Woodchips incredibly simple and clean.Install# Install toolpip3installwoodchips# Install locallyjustinstallUsageALoggerinstance must be created to use Woodchips. Simply specify a name and logging level, tell Woodchips where to log items (console and/or files), and start chipping away!Need multiple loggers, no problem. Spin up separateLoggerinstances for your needs. Maybe you need a console logger for certain output that requires a specific format while another module needs a generic file formatter. Woodchips makes it easy to setup and configure all your loggers.Logging to a file:Woodchips will automatically roll over your log files once it reaches thelog_size. You can configurenum_of_logsto specify how many log files will be kept in the rotation.NOTE:Woodchips has a very small default log size of just200kbwith5log files for a total of1mbof logs. For production applications, these values may need to be drastically increased.Formatters:You can configure the format of log files per handler (console and/or files); however, defaults are set (and shown below) if you just need basic logging.Setting up Woodchipsimportwoodchips# Setup a new logger instancelogger=woodchips.Logger(name='my_logger_name',# The name of your logger instance, often will be `__name__`level='INFO',# The log level you want to use)# Setup console logginglogger.log_to_console(formatter='%(message)s')# Setup file logginglogger.log_to_file(location='path/to/log_files',formatter='%(asctime)s-%(module)s.%(funcName)s-%(levelname)s-%(message)s',log_size=200000,# Size of a single file in bytesnum_of_logs=5,# Number of log files to keep in the rotation)Using Woodchipsimportwoodchips# Retrieve a logger instance by name (assumes it's already been created)logger=woodchips.get('my_logger_name')# Log a message (will be logged to console and a file based on the example from above)logger.info('This is how to setup Woodchips!')Logger LevelsCRITICALERRORWARNINGINFODEBUGNOTSETDevelopment# Get a comprehensive list of development toolsjust--list
Package: woodchopper
A lightweight logging packageTable of contentsBack to TopTable of contentsInstallationUsingpipUnix/mac/linuxWindowsBuilding from sourceUnix/mac/linuxWindowsUsageCreating a logLogging plaintextLogging debug informationLogging informationLogging warningsLogging errorsGetting helpInstallationUsingpipTo install this package using pip, simply run the following command:Unix/mac/linuxpip3installwoodchopperWindowspip install woodchopperBuilding from sourceUnix/mac/linuxRequirements:Python >=3.8.1GitPoetry >=1.5.1Run the following in the terminal:gitclonehttps://github.com/TinkerTown-SEMI/woodchopper.gitcdwoodchopper

makeinstall-dev
make-j4all
makebuildWindowsRequirements:Python >=3.8.1GitPoetry >=1.5.1w64devkit(GNU binaries for windows, includingmake). When you extract the folder, add the folder to the path.Run the following in the terminal:git clone https://github.com/TinkerTown-SEMI/woodchopper.git
cd woodchopper

make install-dev
make -j4 all
make buildUsageCreating a logTo use woodchopper, you first have to create a log.fromwoodchopperimportLogging_Levels,DateTime_Defaults,Styles,LoggerfrompathlibimportPathlog=Logger(Path("./spam.log").resolve(),# Path to log fileshow_datetime=DateTime_Defaults.DO_NOT_SHOW,# Don't show date and time. Other options: DateTime_Defaults.DATE_AND_TIME, DateTime_Defaults.DATE_ONLY, DateTime_Defaults.TIME_ONLYlogging_level=Logging_Levels.DEBUG,# Allow all logging operations. Other options: Logging_Levels.DEFAULT, Logging_Levels.WARNING, Logging_Levels.ERROR, Logging_Levels.SILENT.quiet=True# Suppress log messages on creation and deletion.)Logging plaintextlog.log("Hello, world!")Output:Hello, world!Logging debug informationlog.debug("Ate 1 can of spam. Cans of spam remaining: 25.")Output[^1]:DEBUG:Ate 1 can of spam. Cans of spam remaining: 25.Logging informationlog.info("Sent order for 50 cans of spam.")Output[^1]:INFO:Sent order for 50 cans of spam.Logging warningslog.warn("Running low on spam: 7 cans left.")Output[^1]:WARNING:Running low on spam: 7 cans left.Logging errorslog.error("Houston, we have a problem: cans of spam left: 0.")Output[^1]:ERROR:Houston, we have a problem: cans of spam left: 0.Getting helpYou can get help regarding this package in many ways. If you need help with syntax, your first stop should always be help manuals, so you could use python'sbuilt-in help function, as we do not yet have full documentation published(sorry). For errors, it should be thebug tracker, and for more generic python errors, you could go over toStackOverflow.Happy logging, folks![^1]: Sorry, colored/styled text isn't available in github markdown.
Package: woodder
WoodderA really simple python logger configurator.
It does two things:Formats your logs according to:%(asctime)s - %(name)s - %(filename)s - %(levelname)s - %(message)sCreates alogsdirectory, where it puts all the logs for each run of the application.UsageHere's how you use it:# In a file named: sample_logging.py
import logging
TODO: put wooder import


if __name__ == '__main__':
    project_name = "my_project"
    log_dir = "my_logs"
    Woodder.configure_logging(project_name, log_dir=log_dir)

    logger = logging.getLogger("my-logger")

    logger.info("some info")
    logger.debug("some debug")
    logger.warning("some debug")
    logger.critical("some critical")
    logger.error("some error")Output:2021-02-02 23:23:33,878 - my-logger - sample_logging.py - INFO - some info
2021-02-02 23:23:33,878 - my-logger - sample_logging.py - DEBUG - some debug
2021-02-02 23:23:33,878 - my-logger - sample_logging.py - WARNING - some debug
2021-02-02 23:23:33,879 - my-logger - sample_logging.py - CRITICAL - some critical
2021-02-02 23:23:33,879 - my-logger - sample_logging.py - ERROR - some error
Package: woodland
# Forests
### Helping you see the forest from the trees.[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
[![Build Status](https://travis-ci.org/JHowell45/Forests.svg?branch=master)](https://travis-ci.org/JHowell45/Forests)
[![codecov](https://codecov.io/gh/JHowell45/Forests/branch/master/graph/badge.svg)](https://codecov.io/gh/JHowell45/Forests)Python data types for tree data structures.
Package: woodpecker
Woodpecker is a Python package that aims to be a lightweight — but complete — load generator and analysis tool for various environments.While other far more famous tools like HP LoadRunner(R) or Apache JMeter either propose a complex and heavy application to perform load tests or require a very expensive license to work, Woodpecker’s main focus is on easiness of use, small memory footprint and smartness in data analysis — and, most of all, it is an Open Source Software since is released under the GNU LGPL version 3 license.This project is still in development phase, but first benchmarks shows that the memory footprint for each Virtual User (here calledspawn) is about 516 Kb. When the first development phase will be completed, this package will become publicly available for download from PyPi.RequirementsAt the moment the libraries required to run Woodpecker are the following:python-dateutilcoloramaclickpsutilrequestsAll of them are hosted on PyPi and can be installed usingpiporeasy_install:pip install-rrequirements.txtPlanned featuresCommand-line interface to initialize scenarios, create transactions from HAR files, start/stop controller and remote spawners and analyze resultsFully portable results storage in a single SQLite3 fileGeneric load profile generation by combination of basic ramp elementsCapability to generate load on:Web pages using HTTP protocolSOA servicesDatabasesWeb Video StreamsSocketsPowerful HTML report creation using the Jinja2 templating engine (with PDF output, too)SLA support and real-time ora posterioricheckEasy parameters retrieval and reuse, also in different transactionsCustom transactions supportRequests result assertionsDifferent spawning logic (using threads or sub-processes) to optimize memory consumption different architecturesEasily switch between different load configurations by changing one parameter in command-line invocationEmbedded system monitor (CPU and memory usage) for both controller and spawners
Package: woods
Woods: Decision Tree EnsemblesCurrently implemented algorithms:Partially randomized decision tree (variance minimization).Gradient Boosting of decision trees (MSE minimization).Average ensemble of GBM.Deep Gradient Boosting (of Average ensembles of GBM).TODOImplement median-split, best-split decision tree;Provide optional min&max search based on pre-sorting (find min&max ofarray[indices]);Add different loss-functions, ranking support.InstallationBuild environmentInstallrustup.Set up nightly toolchain:rustup toolchain install nightly
rustup default nightlyInstall Python extensionRunsetup.py:python setup.py install --userNote that--useroption is used to install package locally.Build documentationGo torustdir and run:cargo doc --libDocs will be placed intarget/doc/woods/index.html.
Package: wood-splinter
.. image:: https://secure.travis-ci.org/cobrateam/splinter.svg?branch=master:target: http://travis-ci.org/cobrateam/splinter++++++++++++++++++++++++++++++++++++++++++++++++wood-splinter - python tool for test web applications (splinter fork)++++++++++++++++++++++++++++++++++++++++++++++++wood-splinter is a fork of splinter.splinter is a tool for test web applications with a simple for find elements, form actions, and others browser actions.`what's new in splinter? <https://splinter.readthedocs.io/en/latest/news.html>`_first steps===========* `Installation <https://splinter.readthedocs.io/en/latest/install.html>`_* `Quick tutorial <https://splinter.readthedocs.io/en/latest/tutorial.html>`_splinter open source project============================* `Community <https://splinter.readthedocs.io/en/latest/community.html>`_* `Contribute <https://splinter.readthedocs.io/en/latest/contribute.html>`_documentation=============`splinter documentation <https://splinter.readthedocs.io>`_external links==============`Django Full Stack Testing and BDD with Lettuce and Splinter <http://cilliano.com/blog/2011/02/07/django-bdd-with-lettuce-and-splinter/>`_`Splinter: Python tool for acceptance tests on web applications <http://www.franciscosouza.com/2011/05/splinter-python-tool-for-acceptance-tests-on-web-applications/>`_`Testes de aceitação com Lettuce e Splinter (pt-br) <http://www.slideshare.net/franciscosouza/testes-de-aceitao-com-lettuce-e-splinter?from=ss_embed>`_`salad <https://github.com/salad/salad>`_, a nice mix of great BDD ingredients (splinter + `lettuce <http://lettuce.it>`_ integration)`behave-django <https://github.com/mixxorz/behave-django>`_, BDD testing in Django using `Behave <http://pythonhosted.org/behave/>`_. Works well with splinter.
Package: woodstock
Notice: This is a first draft of an installation guide. It’s not finished
and complete.Make sure you have a working django project setup.Install woodstock with pip:pip install woodstockMake sure that the FeinCMS and Pennyblack Apps are added to your installed apps in yoursettings.py:'woodstock',Install dependencies (overpip):pennyblackfeincmsicalendarAdd Woodstock Models to south migration modules in yoursettings.py:SOUTH_MIGRATION_MODULES = {
    'woodstock': 'project_name.migrations_woodstock',
}Runschemamigrationsandmigrate:./manage.py schemamigration --initial woodstock
./manage.py migrate
Package: woodstove
# woodstove[![Build Status](https://travis-ci.org/richardmarshall/woodstove.svg?branch=master)](https://travis-ci.org/richardmarshall/woodstove) [![PyPi](https://img.shields.io/pypi/v/woodstove.svg)](https://pypi.python.org/pypi/woodstove)A simple [python](https://python.org) framework for building json http apis built ontop of the [bottle](http://bottlepy.org) microframework.## Install```pip install woodstove```## Usage### Example: Hello world```pythonfrom woodstove import app, serverclass Hello(object):wsapp = app.App('/hello')@wsapp.get('/world')def hello_world(self):return "Hi!"s = server.Server()s.mount(Hello())s.run(host='localhost', port=8080)```Run this script then point curl or your browser at http://localhost:8080/hello/world.```$ curl http://localhost:8080/hello/world{"total": 1, "data": ["Hi!"]}```## TestingTODO## ContributingSee [CONTRIBUTING](CONTRIBUTING.md) for details on submitting patches.## LicensingWoodstove is licensed under the Apache License, Version 2.0. See [LICENSE](LICENSE) for full license text.
Package: woofy
woofy🐶 An unofficialThe Dog APIwrapper for Python📦 Packages🐍 PyPIpipinstallwoofy🔎 Examplesexamples/basic.pyimportwoofyclient=woofy.Client()# Let's search for 10 images at oncefor_inrange(10):print(client.images.search())✨ Links🐍PyPI🏠Homepage🐱Repository
Package: woohoocalc
—Name: woohoocalcVersion: 0.0.1Description: woohoocalc is a Python package made for performing essential math calculations for everyday use.Supported Actions:AdditionMultiplicationSubtractionDivisionnth root calculationMemory resetPrint out memory—
How to install this package:installing via terminal -pip install woohoocalcinstalling via IDE -%pip install woohoocalc—
How it works:
-from calculator.calculator import Calculatornew_obj = calc.Calculator()  # New object is created.new_obj.add(15) # Returns 15.0new_obj.subtract(5) # Returns 10.0new_obj.multiply(20) # Returns 200.0new_obj.divide(2) # Returns 100.0new_obj.n_root(2) # Returns 10.0new_obj.return_memory # Returns 10.0new_obj.memory_reset # Resets memory to 0.0—Keywords: calculator, addition, multiplication, subtraction, division, nth rootThis project is licensed under the terms of the MIT license.
Package: woohoo-pdns
This project is an implementation of a passive DNS reqplication database (pDNS)
using SQLAlchemy, Alembic and PostgreSQL.It is geared towards small-ish installations; most likely it is not capable of
handling an ISP’s DNS data volume for example.Learn moreon Read the docs(do not
try to read the documentation in thedocsfolder).The source code can be found inwoohoo pDNS’ home on Gitlab(link mainly for
people reading this on PyPI).
Package: woohoo-pdns-gui
Simple webapplication that can query and display pDNS data delivered from a server that produces
data according to theCommon Passive DNS Output Format.To run, I currently use the following command:$ LC_ALL=en_US.UTF-8 LANG=en_US.UTF-8 FLASK_APP=woohoo_pdns_gui FLASK_ENV=production WOOHOO_PDNS_GUI_SETTINGS="pdns_gui_dev_conf.py" flask runLearn moreon Read the docs(do
not try to read the documentation in thedocsfolder).The source code can be found inwoohoo pDNS GUI’s home on Gitlab(link
mainly for people reading this on PyPI).
Package: wook
WookWook says hello!Table of contentsIntroductionInstallationUsageWith pipFrom sourceLicenseIntroductionThis project is an implementation of greeting fromwook. You can simply install this library and run in your own environment.InstallationWith pipYou can installwookby using pip as follows:$ pip install wookFrom sourceInstead, you can installwookfrom source by cloning this repository and running:$ git clone https://github.com/affjljoo3581/wook.git
$ cd wook
$ python setup.py installUsageAfter installingwook, you can run this library by using belows:$ wookThen wook will sayhello!LicensewookisApache-2.0 licensed.
Package: wookie
Star Wars API WrapperThis is an asynchronous wrapper for theStar Wars APIUsageGetting a character by nameif__name__=="__main__":fromwookieimportStarWarsClientsw=StarWarsClient(base_url="https://starwarsapi.site")character_by_name=awaitsw.get_character_by_name("Luke Skywalker")print("Character by Name:",character_by_name)Get character countif__name__=="__main__":fromwookieimportStarWarsClientsw=StarWarsClient(base_url="https://starwarsapi.site")character_count_=awaitsw.get_character_count()print(character_count)More examples to come... Hold on for a while and referhttps://starwarsapi.site/docs/
Package: wooldridge
Wooldridge Meets PythonData sets fromIntroductory Econometrics: A Modern Approach(7th ed, J.M. Wooldridge)DescriptionA Python package which contains 111 data sets from one of the most famouseconometricstextbooks for undergraduates.It is extensively used inPythonで学ぶ入門計量経済学(Japanese). Its Google-translated version (in the language of your choice) is also available inLearning Introductory Econometrics with Python.It is also used inUsing Python for Introductory Econometrics, which is a sister bookUsing R for Introductory Econometrics.How to UseFirst things first.import wooldridgeTo load a data set named<dataset>:wooldridge.data('<dataset>')It returns pandasDataFrame. Note that<dataset>is entered in strings. For example, to load a data setmrozintodf:df = wooldridge.data('mroz')To show the description (e.g. variable definitions and sources) of a data set:wooldridge.data('mroz', description=True)To show the list of 111 data sets contained in the packagewooldridge.data()How to Installpip install wooldridgeorgit clone https://github.com/spring-haru/wooldridge.git
pip install .NoteThe functiondataWoo()introduced in the previous versions also works:from wooldridge import *

df = dataWoo('<dataset>')

dataWoo('<dataset>', description=True)

dataWoo()ReferenceJ.M. Wooldridge (2019)Introductory Econometrics: A Modern Approach, Cengage Learning, 7th edition.
Package: woollylib
woollylibThis is a pytorch based utilities library which will help you for training and visualizing computer vision models.Structure Tree├── woollylib
│   ├── bp
│   │   ├── autocast
│   │   │     └── backpropagation.py   
│   │   ├── losses
│   │   │     └── backpropagation.py  
│   │   ├── optimizer
│   │   │     └── backpropagation.py  
│   │   ├── ricap
│   │   │     └── backpropagation.py   
│   │   └── vanila  
│   │         └── backpropagation.py   
│   │ 
│   ├── models
│   │   ├── custom
│   │   │     └── custom_resnet.py 
│   │   ├── model.py
│   │   └── resnet.py
│   │ 
│   ├── preloading
│   │    └── dataset.py 
│   │ 
│   ├── utils
│   │    ├── gradcam
│   │    │   ├── _init_.py
│   │    │   ├── compute.py
│   │    │   ├── gradcam.py
│   │    │   └── util.py   
│   │    │
│   │    ├── transform.py 
│   │    ├── utils.py 
│   │    └── visualize.py 
│   │ 
│   ├── _init_.py
│   ├── dataset.py
│   ├── main.py
│   ├── scheduler.py
│   └──training.py
│   
├── setup.py
├── LICENSE
├── MANIFEST.IN
├── README.txt
├── requirements.txt
├── .gitignore
└── README.mdInstallationpip install woollylibHow to Use itContributersAmmar AdilKrithigaShashwat DhanraajSrikanth Kandarp
Package: woolseyworkshop-circuitpython-74hc165
IntroductionCircuitPython driver for 74HC165 shift register.DependenciesThis driver depends on:Adafruit CircuitPythonBus DevicePlease ensure all dependencies are available on the CircuitPython filesystem.
This is easily achieved by downloadingthe Adafruit library and driver bundle.Installing from PyPIOn supported GNU/Linux systems like the Raspberry Pi, you can install the driver locallyfrom
PyPI. To install for current user:pip3installwoolseyworkshop-circuitpython-74hc165To install system-wide (this may be required in some cases):sudopip3installwoolseyworkshop-circuitpython-74hc165To install in a virtual environment in your current project:mkdirproject-name&&cdproject-namepython3-mvenv.venvsource.venv/bin/activatepip3installwoolseyworkshop-circuitpython-74hc165Usage Exampleimporttimeimportboardimportdigitalioimportwws_74hc165latch_pin=digitalio.DigitalInOut(board.D5)sr=wws_74hc165.ShiftRegister74HC165(board.SPI(),latch_pin)pin1=sr.get_pin(1)whileTrue:print(f"pin 1 ={pin1.value}")time.sleep(1)Also see theAdding Digital I/O To Your CircuitPython Compatible Board: Part 2 - The 74HC165tutorial onWoolseyWorkshop.comfor additional usage information.DocumentationAPI documentation for this library can be found onRead the Docs.For information on building library documentation, please check outthis guide.ContributingContributions are welcome! Please read ourCode of Conductbefore contributing to help this project stay welcoming.
Package: woon-vcfg
This module is designed to work with .vcfg configs.All commands:Create a new promotion: new(, )
Get information: get()
Change action: set(, )Example:# Import the library and create a variable for convenience
import vconfig_by_mrwoon as config
cfg = config.Configs("config.vcfg")

# Create a new group
cfg.new("name", "Vasya")

# Display concentration on the screen
print(cfg.get("name"))```
Package: woon-vconfig
This module is designed to work with .vcfg configs.All commands:Create a new promotion: new(, )
Get information: get()
Change action: set(, )Example:# Import the library and create a variable for convenience
import vconfig_by_mrwoon as config
cfg = config.Configs("config.vcfg")

# Create a new group
cfg.new("name", "Vasya")

# Display concentration on the screen
print(cfg.get("name"))```
Package: woopra.py
========================================Woopra Python client with Django support========================================A Pythonic Woopra client with Django support.Installation============::pip install woopra.pyUsage=====Client configuration--------------------At a base level, you can set up the client using keywords or a configurationdictionary::>>> import woopra_tracker>>> config = {'domain': 'www.example.com'}>>> woopra = woopra_tracker.client(**config)User identification-------------------If you have the user information when you create the tracker instance, you canadd it then::>>> config = {'domain': 'www.example.com'}>>> woopra = woopra_tracker.client(user={'email': "bug@insects.com"}, **config)To add identifying information::>>> woopra.identify(name="Stick Bug"){"email": "bug@insects.com", "name": "Stick Bug"}>>> woopra.identify(order="Phasmatodea"){"email": "bug@insects.com", "name": "Stick Bug", "order": "Phasmatodea"}As you can see the `identify` method updates the user with parameters and then returnsthe fully updated user data dictionary.Of course that dictionary can be directly modified, too::>>> woopra.user['name'] = "Stick Bug"To then identify the user to Woopra::>>> woopra.push()Event tracking--------------Track an event::>>> woopra.track('purchase')Add information to the event::>>> woopra.track('purchase', item='Terrarium', price='50.00')Django integration------------------The Django client construction is a shortcut to use a an HttpRequest instanceto create the tracker.>>> woopra = woopra_tracker.django(request)You can pass in missing or alternative values using the keyword pattern here too::>>> woopra = woopra_tracker.django(request, **config)However you should be careful doing that as config values added here will *override*values from the request.License=======MIT license=======History=======0.1.0 (2018-03-08)------------------* First release on PyPI.