Saravanan666/pypi-org huggingface dataset:
Package: jolteon
Are you a Lightdash user? Have you ever had to change the name of a metric, dimension or model in your dbt project?If so, you'd know for sure that adapting the Lightdash charts to these changes is a huge pain.This python package aims to partially solve this issue automatically updating the Lightdash database.It works pretty well most of the times, but there are still some corner cases when you'll find your charts a little bit different after the migration. Anyway, this package will still save you hours of manual updates.How to install Jolteonpip install jolteonHow to use JolteonCreate a.envfile like the.env.exampleone you find in this repository and fill it with your Lightdash database connection parameters.Create aconfig.yamlfile like theconfig_example.yamlone you find in this repository. This file should be structured as follows:old_tableshould be filled with the previous name of your dbt model (if you have changed it) or with the current name of it (if you haven't changed it).new_tableshould be filled with the current name of your dbt model only when you have changed it, otherwise it should be left empty.fields_raw_mappingshould be filled with the mapping of the metrics and the dimensions you have changed. If you haven't changed any metric or dimension, you can also leave it empty.query_idsshould be filled with the ids of the charts you want to affect when updating the database. If you don't known what are the ids of the charts (and you probably won't the first time), you can runjolteon get-ids. You will be presented with a table containing the id, the name and the workspace of all the charts of your Lightdash instance.Runjolteon update-db config.yaml.
Package: joltos
The aim of JoltOS is to become a framework for building custom Linux images
based on popular distributions, such as Debian, Ubuntu, Alpine, etc. Unlike
Yocto, the intention is not to build distributions from scratch, but to
utilize pre-built binaries to the greatest extent possible through publically
available Docker images and package repositories.PrerequisitesJoltOS is built upon the Jolt task execution tool. Install both with:$pipinstalljoltosPython 3.9 or later is required.JoltOS also needs Docker. Version 20 or later is recommended. The latest version can be installed with:$curlhttps://get.docker.com|shFor cross-platform builds, the binfmt-support and qemu-user-static packages are required.
Install them with your system’s package manager:$sudoaptinstall-ybinfmt-supportqemu-user-staticBuilding an ImageA minimal example image is available in theexamples/minimalsubdirectory. Build it by running this Jolt command:$joltbuildminimal/debian:board=qemuCustomizing ImagesCreate a Jolt Python class inheriting either AlpineImage or DebianImage.
Both base classes define different attributes that can be overridden to
customize the image.install_files - List of files to be copied into the image.install_pkgs - List of packages to be installed using the distro package manager.install_tasks - List of Jolt task artifacts to be copied into the image.remove_files - List of files to remove from the image.remove_pkgs - List of packages to be removed using the distro package manager.Image formats are chosen using decorators:joltos.attributes.squashfs - Builds a squashfs imagejoltos.attributes.tar - Builds a tar archiveMultiple image types can be built at once.@joltos.attributes.squashfs@joltos.attributes.tarclassMinimalDebianRootfs(DebianRootfs):""" A minimal rootfs with systemd, as squashfs and tar images """name="minimal/debian"install_pkgs=["nano"]remove_files=["/usr/share/doc","/usr/share/man",]To build different variants of an image for different types of boards you
can add conditional attributes that are selected based on the values of
build parameters. Example:@joltos.attributes.tar@joltos.attributes.install_pkgs("install_pkgs_{board}")@joltos.attributes.install_pkgs("install_pkgs_{variant}")classMinimalDebianRootfs(DebianRootfs):""" A minimal rootfs with systemd, as squashfs and tar images """name="minimal/debian"# This attribute is always selectedinstall_pkgs=["nano"]# This attribute is selected when variant=debuginstall_pkgs_debug=["gdb"]# This attribute is selected when board=qemuinstall_pkgs_qemu=[]$joltbuildminimal/debian:board=qemu,variant=debug
Package: jom
JOM Django JsonField simple managerJOM Object helps you to handle JsonField in django frame work
so that you can (delete | edit | add ) values and gets the result from the function
result()
you can get two types of results (str -> json object | dict -> python object)examplefromjomimportJOM# or you can import it as JsonObjectManager# asign the object you want to handle# json formatdata='{"name":"Hussein Naim ","site":"https://iamhusseinnaim.github.io","age":22}'# allowed fields to deal withallowed=['name','site','age']# create the instanceinstance=JOM(data,allowed=allowed)# delete a certain iteminstance.del_item("age")# holding the resultresult=instance.result()# print out the resultprint(result)# output: default = return as json | str# "{'name':"Hussein Naim ","site":"https://iamhusseinnaim.github.io"}
Package: jomiel-comm
jomiel-commThePythonlibrary for communicating withjomiel.Requirementsjomiel-commis written forPython3.6 and later.Installationpipinstalljomiel-commBuilding packages from repogitclonehttps://github.com/guendto/jomiel-commcdjomiel-comm
gittag-sKEYID-am'jomiel-comm version VERSION (INITIALS)'TAGNAME
pipinstallpep517
python-mpep517.build[-s|-b].The packages are created under the dist/ dir.Licensejomiel-commis licensed under theApache License version 2.0.Acknowledgementsjomiel-commusespre-commitand its many hooks to lint and format
the project files. See the .pre-commit-config.yaml file for details.
Package: jomiel-kore
jomiel-koreThe minimalistic foundation for creating newPythonapplications.Requirementsjomiel-koreis written forPython3.6 and later.Installationpipinstalljomiel-koreInstall from the repository, e.g. for development:gitclonehttps://github.com/guendto/jomiel-korecdjomiel-kore
pipinstall-e.# Install a project in editable modeOr, if you'd rather not install in "editable mode":pipinstallgit+https://github.com/guendto/jomiel-koreLicensejomiel-koreis licensed under theApache License version 2.0.Acknowledgementspre-commitis used for linting and reformatting, see the.pre-commit-config.yamlfile
Package: jomiel-messages
jomiel-messagesThe Python bindings for thejomielprotobuf messages.AboutThe bindings have been generated from the protobuf declaration files ofjomiel-protoInstallationpipinstalljomiel-messagesInstall from the repository, e.g. for development:gitclonehttps://github.com/guendto/jomiel-messages.gitcdjomiel-messages
./bin/gen
pipinstall-e.UsageSerialize an inquiry message:fromjomiel_messages.protobuf.v1alpha1.message_pb2importInquiryinquiry=Inquiry()inquiry.media.input_uri='https://foo.bar/baz'serialized_string=Inquiry.SerializeToString(inquiry)# ...De-serialize a response message:fromjomiel_messages.protobuf.v1alpha1.message_pb2importResponsefromjomiel_messages.protobuf.v1alpha1.status_pb2importSTATUS_CODE_OKresponse=Response()response.ParseFromString(serialized_string)ifresponse.status.code!=STATUS_CODE_OK:print(f"message={response.status.message})print(f"status-code={response.status.code}")print(f"error-code={response.status.error}")print(f"http-code={response.status.http.code}")# ...else:# ...Licensejomiel-messagesis licensed under theApache License version
2.0.AcknowledgementsSubprojects (as git subtrees)src/jomiel_messages/proto/ofjomiel-proto
Package: jommerce
Why does this package exist?Because 80% of customer projects have common apps
such as authentication, store, admin, blog, forum, academy, etc.
Therefore, as freelancers, we decided to code all these apps only once in one place
and use them in different projects as often as desired,
and all these apps can be customized by the settings of each project.
This helps to save our time and increase our income in exchange for doing projects.InstallingYou can use pip to installjommercefor usage:pipinstalljommerceUsageCreate ProjectSimple command line for jumpstarting production-ready Django projects:jommerceorpython-mjommerceAuth#settings.pyINSTALLED_APPS=[# ..."jommerce.auth",# ...]MIDDLEWARE=[# ...'jommerce.auth.middleware.AuthenticationMiddleware',# ...]# urls.pyfromdjango.urlsimportpath,includeurlpatterns=[# ...path("auth/",include("jommerce.auth.urls",namespace="auth")),# ...]Blog#settings.pyINSTALLED_APPS=[# ..."jommerce.blog",# ...]# urls.pyfromdjango.urlsimportpath,includeurlpatterns=[# ...path("blog/",include("jommerce.blog.urls",namespace="blog")),# ...]ContributingContributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions you make aregreatly appreciated.If you have a suggestion that would make this better, please fork the repo and create a pull request. You can also simply open an issue with the tag "enhancement".
Don't forget to give the project a star! Thanks again!Fork the ProjectCreate your Feature Branch (git checkout -b feature/AmazingFeature)Commit your Changes (git commit -m 'Add some AmazingFeature')Push to the Branch (git push origin feature/AmazingFeature)Open a Pull Request
Package: jomvst
No release out yet!jomvst is a joint-based stick figure manipulator. “jomvst” is short
for “joints move sticks”.jomvst can be used both as a command line tool and as a Python
module. It requires Python 3.1+.jomvst is part of the roptoligs project (but can be used independently
of other roptoligs modules). See the roptoligs wiki athttp://roptoligs.metanohi.org/for details.Licensejomvst is free software under the terms of the GNU Affero General
Public License version 3 (or any later version). This is version 0.1.0
of the program.InstallationTo install jomvst, run:python3 setup.py installYou must be a superuser to do this.Use as command line toolWhen you have installed jomvst, run:jomvst --helpto see how to interact with jomvst via the command-line.Use as Python moduleWhen jomvst has been installed, it can be used just like any other
Python module. To see which parts of the module are useful, and to see
how those parts function, run:pydoc3 jomvstjomvstcan be imported with a simpleimportstatement.Developmentjomvst uses Git for code management. To get the latest branch,
clone it from gitorious.org like this:$ git clone git://gitorious.org/jomvst/jomvst.gitThis documentCopyright (C) 2011  Niels SerupCopying and distribution of this file, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved.  This file is offered as-is,
without any warranty.
Package: jondis
# OverviewJondis is a high availability pool management class for the excellenthttps://github.com/andymccurdy/redis-py# FeaturesSlave discovery on startupOn master failure, if a slave is promoted, the pool will reconfigure to connect to the new master# LimitationsCurrently all commands are sent to the masterNo master discovery if only a slave server is providedIn certain scenarios, the pool will pick up new slaves (if it’s reconfigured), but
there’s currently no periodic / automatic slave discoveryDoes not talk to sentinel# Requirementsredis-py# UsageIn order to configure the pool, you’ll need to provide at least 1 active master server.  This is a limitation that
will be lifted soon with master discovery.`python from jondis.pool import Pool pool =Pool(hosts=["redis01:6379","redis02:6379"])redis = redis_lib.client.StrictRedis(connection_pool=pool) `
Package: jones-complexity
Flake8 extension to calculate per-line complexity and total code
density.Installation$ pip install jones-complexityUsage (Standalone)$ python -m jones_complexity --min 5 your_file.pyUsage (flake8)$ flake8 --max-line-complexity 15 --max-jones-score 8 yourprojectWhat is this?Becauseifuser.get_full_name().toUpper().split(' ')[0]=='ALICE':returnTrueis harder to read and maintain thaniffirst_name=='Alice':returnTrueShamelessly named after myself, in the tradition of McCabe and Halstead.ExamplesItself:$ python jones_complexity.py jones_complexity.py
Line counts:
{
    "39": 19,
    "46": 15,
    "137": 12,
    "115": 12,
    [...]
    "18": 1,
    "9": 1,
    "148": 1
}
Jones Score:
4.0PyEsprima:$ p jones_complexity.py pyesprima.py
Line counts:
{
    "4182": 265,
    "3688": 190,
    "4186": 189,
    "48": 189,
    "4181": 164,
    [...]
    "1201": 1,
    "3728": 1
}
Jones Score:
9.0
Package: jonf
JONF parser/formatter in PythonNOTE: This is an early alpha versionJONF format docs:https://jonf.app/Formatter is implemented andtestedParser is not implementedyetPython example:# pip install jonfimportjonf,textwraptext=textwrap.dedent("""\compare =- true= true""").rstrip()data={"compare":["true",True,]}# TODO:# assert jonf.parse(text) == dataassertjonf.format(data)==textprint(jonf.format(data))Output:compare =
  - true
  = true
Package: jongten
🧮🀄️jongten🀄️🧮CLI trainer for calculating riichi-mahjong points🀄️🧮🀄️jongten🀄️🧮InstallationUsageInstallationpip install jongtenUsage🐑🌙 jongten
🀚 🀚 🀇 🀈 🀉 🀉 🀊 🀋 🀝 🀞 🀟 🀒 🀓 🀔

ツモ:🀔 リーチ無 場風: 東 自風: 南
親の支払う点数: 700
子の支払う点数: 400

正解!!
Package: jonsnow
jonsnow is a tool to make running unit tests, etc. easier. Run it in a separateterminal from where you're doing your editing and it will run an arbitrary shellcomand whenever you change a file in a specified directory.Usage:jonsnow ./fight_white_walkers.shjonsnow -r ../ echo "You know nothing..."Arguments:-r, --root PATH: specify the root directory you want {} to format.Defaults to the current working directory.--rtp PATH: Set the runtime path of the command you want to execute
Package: jonze
JonzeJoint Slot and Intent Extraction implementation in Tensorflow2.0Contains restructured code from the following repo:https://github.com/shubham8111/Joint-NLUImplementation of Bi-LSTM based NLU baseline and SlotGated-SLU  (Goo et al, 2018)(https://www.csie.ntu.edu.tw/~yvchen/doc/NAACL18_SlotGated.pdf)
Models are evaulated on Snips and ATIS datasets.Experiments did not reproduce improvements by SlotGated model over Basline model, on snips dataset.Preprocessing modules reused from following repo:https://github.com/MiuLab/SlotGated-SLU/UsageTo install package:pip install jonzeTo train model:from jonze import train   train(dataset = "joint-nlu", datasets_root = "dataset", models_root = "model", layer_size=12)To test model:from jonze import test   test(dataset = "joint-nlu", datasets_root = "dataset", models_root = "model", layer_size=12, batch_size=46)ResultsSnips Dataset:ModelSlot F1Intent accuracySemantic AccuracyBaseline84.3096.5766.43Slot Gated83.595.5766.85Atis Dataset:ModelSlot F1Intent accuracySemantic AccuracyBaseline95.0894.6281.97Slot Gated94.5796.4183.65P.S.  Sometimes Slot F1 might get stuck at zero during training, better weight intialization or training a few epochs only on slot loss can resolve the issue.
Package: jook
Install JookYou can install Jook from the Pyhon Package Index:$pipinstalljookBasic UsageJook allows you to create Python objects that can fire off HTTP requests that
mock webhook events from a Jamf Pro server.Getting started is easy:>>>importjook>>>computer=jook.Computer('http://localhost','ComputerAdded')>>>computer.fire()Jook supports bothJSONandXMLformats for data to send (JSONis the default):>>>computer=jook.Computer('http://localhost','ComputerCheckIn',mode='xml')>>>computer.to_xml()'<?xml version="1.0" encoding="UTF-8" ?><JSSEvent><webhook><webhookEvent>ComputerCheckIn</webhookEvent>...</JSSEvent>'>>>computer.to_json()'{"webhook": {"webhookEvent": "ComputerCheckIn", "id": 1, "name": ""}, "event": {...}'Create objects inrandomizemode to generate unique data with everyfire:>>>rand_comp=jook.Computer('http://localhost','ComputerInventoryCompleted',randomize=True)>>>rand_comp.data{'webhook':{...},'event':{...,'udid':'0699A579-2835-4E5F-8847-944D9A477DDD','serialNumber':'CPFQ2MXCG5ND',...}}>>>rand_comp.data{'webhook':{...},'event':{...,'udid':'1ABE2310-4396-4ABC-AAA9-5B48E6CFC7F5','serialNumber':'C1FK9EXSFKQT',...}}CreateDeviceDataandLocationDataobjects to pass into webhooks to control
the data sent in the mock events:>>>my_device=DeviceData('computer')>>>my_device.serial_number'CPFQMEE3HYFH'>>>comp1=Computer('http://localhost','ComputerAdded',device=my_device)>>>comp1.device.serial_number'CPFQMEE3HYFH'>>>comp2=Computer('http://localhost','ComputerCheckIn',device=my_device)>>>comp1.device.serial_number'CPFQMEE3HYFH'Set events to run in a loop with a set delay. This example sets a timer delay of
five seconds and then starts a loop of 10firecalls:>>>computer=jook.Computer('http://localhost','ComputerCheckIn',timer=5)>>>computer.start_timer(repeat=10)
Package: joolyterdemo
Joolyter was developed in the course of Bachelor thesis ‘A Gamification Approach to the Teaching of Space Flight Mechanics’. It represents the core application, interpreting solution scripts to use kRPC to communicate with KSP.Source code:https://github.com/Joolyter/paul-thesis/tree/main/PythonInput/srcDocumentation:https://joolyter.github.io/paul-thesis/PythonInput/src/docs/_build/html/index.html
Package: joon-oiio
py-oiioPython wheels for OpenImageIOCurrently, just a simple explainer, etc on how to create a usable python module.UsageimportoiiofromoiioimportImageInput,ImageOutputfromoiioimportImageBuf,ImageSpec,ImageBufAlgoEverything else should be the same as in the officialOIIO documentation.Windows build stepsGet vcpkg and run script to installInstall OpenImageIO./vcpkg install openimageio[pybind11]:x64-windowsCopy thevcpkg\installed\x64-windows\lib\python3.10\site-packages\OpenImageIO.cp310-win_amd64.pydfile tooiioCopy DLLs fromvcpkg\installed\x64-windows\bintooiioRename pyd file toOpenImageIOReleasing on PyPIFollow the above steps to build OpenImageIO for PythonNavigate to the root directoryRunpy -m buildThen runtwine upload dist/*and follow the prompts.LicenseLicensed under the MIT license.
Package: jootranslate
jootranslatehintThe needed directory structure has changed in version 0.7.2Used search filters in php and xml files:JText::_(“COM_COMPONENTNAME”)JText::script(“COM_COMPONENTNAME”)label=”COM_COMPONENTNAME”description=”COM_COMPONENTNAME”hint=”COM_COMPONENTNAME”title=”COM_COMPONENTNAME”<name>COM_COMPONENTNAME</name><description>COM_COMPONENTNAME</description><![CDATA[COM_COMPONENTNAME]]>This is just a little helper so you don`t have to copy and paste all
your translation strings by hand.Your ini files need the following syntaxTRANSLATION_STRING = 'translation'
do not use a syntax like
TRANSLATION_STRING='translation'

and only use ' not "Or you start without any ini files and let jootranslate create it for you.Your component needs the following directory structureadmin
    - controllers
    - language
    - etc ...
site
    - controllers
    - language
    - etc...installationuse pippip install --user jootranslatelocalpython setup.py installusagejootranslate --source /path/to/component/root --com your_componentto see a full list of all optionsjootranslate -h

usage: jootranslate [-h] -s PATH -c COM [-l LANG] [-t]

A translation ini file generator for joomla developers

optional arguments:
  -h, --help            show this help message and exit
  -s PATH, --source PATH
                        directory to search in
  -c COM, --com COM     the name of the component
  -l LANG, --lang LANG  language localisation. default is en-GB
  -t, --translate       If you want to translate the strings on console
Package: jooxy
ContentsRequirementsInstallationUsageUnofficial Joox Web APIHomepage:https://github.com/ervan0707/jooxyRequirementsThe linepy module only requires Python 3InstallationInstallation is simple. It can be installed from pip using the following
command:$ pip install jooxyOr from the terminal:$ python setup.py installUsage>>> from jooxy import *
>>> joox = Jooxy('EMAIL', 'PASSWORD')
>>> #or
>>> joox = Jooxy('EMAIL', 'PASSWORD', saveData=False)
>>> #or
>>> joox = Jooxy()_.
Package: joplan
JoPlan - Arrange Jobs as PlanInstallation$pipinstalljoplanUsageDemo 1importloggingfromjoplanimporttake,do,everylogging.basicConfig(level=logging.INFO)deff1():print('Making F1')deff2():print('Making F2')take(every('2s').do(f1),every('3s').do(f2),).run()Demo 2fromjoplanimporttake,do,everytake(do('pkg.mod.func1').every('5s'),do('pkg.mod.func2').every('3m'),).run()
Package: joplin-jrnl
Joplin-jrnlThis is a CLI to append notes to a notebook as a running, append-only journaling system.  The general inspiration was thejrnlcommand line tool.  I like the general simplicity of how it works, but wanted the data to be more accessible through Joplin, which I use for general notetaking.How the heck do I use this?joplin-jrnl has been published to PyPi, so you should be able to get this
running by simply executingpip install joplin-jrnl.  You may then run thejjcommand to see how to further interact with it.This is an early development version, as such there aren't many sanity checks in
place.  So at the moment you have to create an area for the configuration to
live and there is currently no option to specify an alternate location (I'll get
there ;) )Create a note in joplin that will serve as your journalIn order for the script to work, you must have a note designated as the journal.
To do this:1. Open Joplin
2. Create a note (you can name it anything you wish)
3. Right click the note and select "copy markdown link"
4. You will get a value like "[note-name](:/df36fc8138da4169b29f0a577cba601e)  You need to paste in just the 'df36fc8138da4169b29f0a577cba601e' part as the note id in ~/.config/jj/conf.yaml.create configuration file and path1. `mkdir ~/.config/joplin-jrnl/`
2. `cp conf.yaml ~/.config/joplin-jrnl/`
3. Edit conf.yaml to reflect your valuesdemoRoadmap/Hopes and DreamsAdd entries to a joplin noteOptionally use editor to make bigger edits (or to deal with annoying
characters in entry that shell wants to expand to somethingSearch for entries based on contentSearch for entries based on tagsMore intelligent handling of optionsCreate a note if you don't specify oneUtilize options to override settingsPrint out entries to CLIBasically work like jrnl, but with joplin :)Figure out asyncio stuff and use that instead of requests
Package: jordan-py
Jordan ?Jordan project let an executing program being interacted with, from anywhere.
Once registered to a Jordan server, a program instance becomes a Jordan client
which may emit statuses (such as logs and progress details), and may react to some user action.
For example, a Human user may want to trigger an email sending for reporting purpose.
Actions are generic, as much as the App GUI. Therefore, you already have an App for your program !Get startedGet a working Jordan server instanceImport jordanfrom jordan_py import jordanIn your Python program, register to this serverjordan_instance = jordan.register('<jordan_server_url>')Send a statusjordan_instance.send_status('The program is well started.')React on received messagewhile True:
     if jordan_message = jordan_instance.read_message():
             if jordan_message.action_name == 'BREAK_LOOP':
                 breakMore use casesExploresamplesfor details on features like :actiontaskstatus typeActionHas a name, and optionally (typed) (defaulted) parameters.
e.g.actions = jordan.with_action('send_email')
                .with_parameter('recipient')
                .with_parameter('delay', jordan.PARAMETER_TYPE_INT, 0)
                .build()

        jordan_instance = jordan.register('<jordan_server_url>', 'sample-client-sending-email', actions)TaskHierarchy of task/sub-task. The jordan client instance returned byregister()function is a root task.meal_task = dinner_jordan_instance.create_task('meal')
    dessert_task = dinner_jordan_instance.create_task('dessert')
    meal_task.send_status('Not enough food in storage')
    dessert_task.send_status('Dessert is ready')Status TypeMay be easier to understand and analyze statuses (in a client app which allows filtering).meal_task.send_failure_status('Not enough food in storage')
    dessert_task.send_status('Dessert is being prepared')
    dessert_task.send_progress(50)
    dessert_task.send_success_status('Dessert is ready')
    dessert_task.send_typed_status('eaten', 'Dessert has been eaten by Michael')