Saravanan666/pypi-org huggingface dataset:
Package: redminecli
Redmine CLIInstallation$ pip3 install --user redminecliConfigurationThe client looks for the config in three places:~/.redmine.conf,~/.redmine/redmine.confand~/.config/redmine/redmine.conf.[accounts]
default=account1

[account1]
url=https://account1.example.com
key=KEY

[account2]
url=https://account2.example.com
key=KEY
ssl_verify=False

[aliases]
...AliasesYou can define aliases forissue filteringall commands:[aliases]
wip = issues --status 2
blocked = issues --status 7
in_progress = update --status 2UsageUsage: redmine [OPTIONS] COMMAND [ARGS]...

Options:
  --force / --no-force  Invalidate cache  [default: False]
  --account TEXT        Account name to use
  -h, --help            Show this message and exit.

Commands:
  create   Create new issue
  issues   List issues
  list     List various resources
  open     Open issue in browser
  project  Project commands
  show     Show issue details
  update   Update issue
  version  Print versionCreate a new issue$ redmine create \
    --status 1 \
    --tracker 1 \
    --project 88 \
    --priority 3 \
    --subject "Fix json output" \
    --description "json output doesn't work for specific issue numbers"For more options seeredmine create --help.Update an issue$ redmine update 107873 --assignee 112For more options seeredmine update --help.Filter issues$ redmine issues --assignee 112 --project 88For more options seeredmine issues --help.See specific issues row by row$ redmine issues 107873 109789JSON Output$ redmine issues --assignee 112 --json
$ redmine issues 107873 109789 --jsonShow issue details$ redmine show 107873This will open issue details inless.See project roadmap$ redmine project 88 roadmapList users$ redmine list userMulti account# This will use the default account in the redmine.conf
$ redmine issues --assignee 112

# This will use account2
$ redmine --account account2 issues --assignee 2194ContributingCurrently, project's roadmap is dictated by my needs at work. If you need a
feature or encountered a bug please open an issue. If you're OK to invest time
in this project all PR's are welcome.
Package: redmine-cmd
A Remote CMD for Redmine based on REST/APIInstallationpip install redmine-cmdUsageUsage: redmine-cmd [options]Options:-h, --help            show this help message and exit
-c CONFFILE, --conffile=CONFFILE
                      Conffile (default: .redmine_cmd.cfg)
-l LOGFILE, --logfile=LOGFILE
                      Log file (default: /dev/stdout)
--loglevel=LOGLEVEL   Log level (default: 20)Usage of the interactive shellAvailable commands:EOF               createtask  help          settask  updatetask       viewusers
change            end         prev          status   viewcurrenttask
changetaskstatus  endtask     previoustask  tasks    viewtasks
create            exit        set           up       viewtimesConfiguration fileSeehttps://github.com/psaavedra/redmine-cmd/blob/master/cfg/redmine_cmd.cfg.exampleCommentsredmine-cmd requires the Web Services activation in Redmine
Package: redmine_migrator
Migrate Redmine data from SQLite to Postgres with consistent type conversion.Installation$pipinstallredmine_migratorDevelopment version$virtualenv~/venv/migrator$source~/venv/migrator/bin/activate$gitclonehttps://github.com/avanov/redmine_migrator.git~/projects/migrator$cd~/projects/migrator$pythonsetup.pydevelopTests$pythonsetup.pynosetestsUsage$redmine_migrator-husage:redmine_migrator[-h][-v]sqlite_urlpostgres_urlMigrateRedminedatafromSQLitetoPostgrespositionalarguments:sqlite_urlSQLitesourceURLpostgres_urlPostgrestargetURLoptionalarguments:-h,--helpshowthishelpmessageandexit-v,--verboseincreaseoutputverbosityExample$redmine_migratorsqlite:////path/to/sqlite_redmine.dbpostgresql+psycopg2://user:password@:port/dbname?host=/var/run/postgresql
Package: redmine-releasedate
Redmine releasedate===================Track when your features are shipped to production in Redmine.Currently supports git & jenkins... image:: https://travis-ci.org/futurecolors/redmine-releasedate.png?branch=master:target: https://travis-ci.org/futurecolors/redmine-releasedate.. image:: https://coveralls.io/repos/futurecolors/redmine-releasedate/badge.png?branch=master:target: https://coveralls.io/r/futurecolors/redmine-releasedate.. image:: https://pypip.in/v/redmine-releasedate/badge.png:target: https://crate.io/packages/redmine-releasedate/How it works------------Upon finishing deploy job, jenkins creates a git tag, so it can track commits that refer to the build.We can use these tags to track which tickets were deployed.Date of deploy is stored in custom field of each ticket that was mentioned in commit.A comment is left for every ticket in release as well for readability.Installation------------Server~~~~~~Install it where your git repo resides. We only support local git repos, so make sure you have enough permissions.* ``pip install redmine-releasedate``* Specify redmine access options in ``releasedate.cfg``* run ``redmine-release-server`` and make it available via http::# releasedate.cfg[redmine]url = http://example.comtoken = your_api_token_goes_herereleased_at_id = 42  ;custom field id goes here[releasedate]message = Deployed on %(instance)s at %(date)s in release "%(release_id)s":%(release_url)saddress = 0.0.0.0  ; optionalport = 8080  ; optionalJenkins~~~~~~~* Pip install ``redmine-releasedate`` on your jenkins server. No configuration is needed.* Add this to your Jenkins build step (preferably, in `post-build task`_)::git push --tagsredmine-release http://releasedate_url/ /path/to/repo/ [instance_url].. _post-build task: https://wiki.jenkins-ci.org/display/JENKINS/Post+build+taskRedmine~~~~~~~Create a user with permissions to edit tickets and post notes in your project.Obtain his API token and put it into ``releasedate.cfg``.Add custom field to store releasedate information.Limitations-----------* second run of client command will make second comment and overwrite release date, so please make sureyou run ``redmine-release`` only once per deploy.See also--------* `Redmine hudson plugin`_* `Jenkins redmine plugin`_.. _Redmine hudson plugin: http://www.r-labs.org/projects/r-labs/wiki/Hudson_En.. _Jenkins redmine plugin: https://wiki.jenkins-ci.org/display/JENKINS/Redmine+PluginChangelog=========0.1.2 (01-07-2013)------------------* Fixed setup.py0.1.1 (01-07-2013)-----------------* Added 3rd optional ``instance_url`` argument to ``redmine-release`` command* Fixed redmine-release-server cli command* Fixed unicode message handling in config* Improved logging0.1 (01-07-2013)----------------* Initial release
Package: redmon
Monitor a Redis keyInstallationRedmon requires a working Redis connection.To install Redmon from pip,pip install redmonOr from source,python setup.py installSetupRedmon connects to your Redis connection with the following environment
variables. If none are set, default values are used. -
REDMON_REDIS_HOST (default,localhost) : Set it to where your
Redis is running from. - REDMON_REDIS_PORT (default,6379) : Set
it to where your Redis is running on. - REDMON_TIME_INT (default,1.0) : Set refresh interval for your Redis keyGet StartedTo watch a Redis key, just simplyredmon monitor --key=sampleRedmon now watches a key calledsampleevery second.Setting Refresh IntervalsChanging the refresh interval for your monitor is very simple. You can
either set it with an environment variable or by passing it as an
argument.REDMON_TIME_INT=2 redmon monitor --key=sampleredmon monitor --key=sample --interval=2Redmon now watches a key calledsampleevery two seconds.Intervals passed as arguments take precedence.REDMON_TIME_INT=2 redmon monitor --key=sample --interval=3Redmon now watches a key calledsampleevery three seconds.Running TestsRedmon usespytestto write/run test cases. To run the test cases,cd tests
py.testContributingForkthis repo[Clone] (https://help.github.com/articles/cloning-a-repository/) your
newly forked repoWrite relevant test casesRaise pull requests toswaathi/redmonComing UpMonitor multiple keysSet the values your Redis key should be compared againstSet the values your Redis key should never be
Package: redmq
redmqRedis message queue utils: a simple distributed lock based on redis, a simple message queue based on redis with ack feature.Installpip install redmqUsage Examplesredmq.lock.RedisLockimport redis
from redmq.lock import RedisLock

conn = redis.Redis()
lock_name = "test01_lock"

with RedisLock(conn, lock_name) as locked:
    if locked:
        pass # do things if acquired the lock
    else:
        pass # do things if not acquired the lockredmq.message_queue.MessageQueueworker.pyimport time
import redis
from redmq.message_queue import MessageQueue

conn = redis.Redis()
mq = MessageQueue(conn)
while True:
    task = mq.pop_nowait()
    if task:
        message = task["message"]
        mq.acknowledge(task, result_data=message.upper())
    else:
        time.sleep(0.1)client.pyimport time
import redis
from redmq.message_queue import MessageQueue

conn = redis.Redis()
mq = MessageQueue(conn)
task1 = mq.push("task1")
task_info = None
for _ in range(100):
    task_info = mq.get_result_nowait(task1)
    if task_info:
        break
    time.sleep(0.1)
print(task_info["result"])start workerpython3 worker.pystart clientpython3 client.pyclient outputtest@test redmq % python3.9 client.py 
{'error_message': 'OK', 'result_data': 'TASK1', 'success': True, 'error_code': 0}redmq.message_queue.Consumerconsumer.pyimport redis
from redmq import MessageQueue
from redmq import Consumer

def pingpong_handler(msg):
    return "pong"

conn = redis.Redis("redis")
mq = MessageQueue(conn)
consumer = Consumer(mq)
consumer.register_handler("debug.pingpong", pingpong_handler)
consumer.start()
consumer.wait()client.pyimport redis
from redmq import MessageQueue

conn = redis.Redis("redis")
mq = MessageQueue(conn)
task = {
    "handler": "debug.pingpong",
}
response = mq.pushwait(task)
print(response["result"])resulttest@test redmq % python3 examples/client.py
{'error_message': 'OK', 'result_data': 'pong', 'success': True, 'error_code': 0}Why NOT using blpop instead of lpop?We do pop_nowait via LUA script, but redis is NOT allow us to use blpop in LUA script.Releasesv0.1.0First release.v0.1.1redmq.message_queue.MessageQueue.push takeshigh_priorityparameter. Normal message use FIFO rule, andhigh_prioritymessage use LIFO rule.v0.2.0Add redmq.message_queue.Consumer, redmq.message_queue.RequestsHandler, redmq.message_queue.RequestsConsumer.Add redmq.schedule.Schedule and redmq.schedule.Scheduler.Add redmq.lock.RedisLock.renew method.Extend redmq.lock.RedisLock.acquire to allow the same worker acquire the same lock many times.Add generic async message queue handler serverrequests-server.v0.2.1redmq.schedule.add_runonce_task, redmq.schedule.add_crontab_task, redmq.schedule.add_interval_task add update paraemter to control if update the schedule by force or not.Fix redmq.schedule.add_crontab_task timezone problem.Fix redmq.schedule.add_interval_task rule change problem.
Package: redmx
redmxRate, Errors and Duration MetricsBasic ExampleimporttimefromredmximportRateErrorDurationmetrics=RateErrorDuration()time.sleep(1)metrics.increment_count(1)metrics.increment_count(1)metrics.rate()print(metrics)Will produce the following output:rate = 1.9904 tps, errors = 0 in 2 (0.0%), duration = 502.4475 milliseconds per transaction.For full documentation please go tohttps://redmx.readthedocs.io/en/latest/
Package: redner
redner is a differentiable renderer that can take the
derivatives of rendering output with respect to arbitrary
scene parameters, that is, you can backpropagate from the
image to your 3D scene. One of the major usages of redner
is inverse rendering (hence the name redner) through gradient
descent. What sets redner apart are: 1) it computes correct
rendering gradients stochastically without any approximation
and 2) it has a physically-based mode – which means it can
simulate photons and produce realistic lighting phenomena,
such as shadow and global illumination, and it handles the
derivatives of these features correctly. You can also use
redner in a fast deferred rendering mode for local shading:
in this mode it still has correct gradient estimation and
more elaborate material models compared to most differentiable
renderers out there.
Package: redner-gpu
redner is a differentiable renderer that can take the
derivatives of rendering output with respect to arbitrary
scene parameters, that is, you can backpropagate from the
image to your 3D scene. One of the major usages of redner
is inverse rendering (hence the name redner) through gradient
descent. What sets redner apart are: 1) it computes correct
rendering gradients stochastically without any approximation
and 2) it has a physically-based mode – which means it can
simulate photons and produce realistic lighting phenomena,
such as shadow and global illumination, and it handles the
derivatives of these features correctly. You can also use
redner in a fast deferred rendering mode for local shading:
in this mode it still has correct gradient estimation and
more elaborate material models compared to most differentiable
renderers out there.
Package: redner-test
redner is a differentiable renderer that can take the
derivatives of rendering output with respect to arbitrary
scene parameters, that is, you can backpropagate from the
image to your 3D scene. One of the major usages of redner
is inverse rendering (hence the name redner) through gradient
descent. What sets redner apart are: 1) it computes correct
rendering gradients stochastically without any approximation
and 2) it has a physically-based mode – which means it can
simulate photons and produce realistic lighting phenomena,
such as shadow and global illumination, and it handles the
derivatives of these features correctly. You can also use
redner in a fast deferred rendering mode for local shading:
in this mode it still has correct gradient estimation and
more elaborate material models compared to most differentiable
renderers out there.
Package: rednet-scraper
Titlerednet ScraperDescrptionWith rednet Scraper you can scrape search results and extract the contents produced by the search result.In rednet scraper it will scrape the data present of the website and give json data which contains the details of the contents on the website.Run Scraperfromrednet_scraperimport*link="https://health.rednet.cn/channel/952.html"data=run_rednet_scraper(link)How it works?It takes URL of rednet page with a search keyword to scrape the data.It generates the json data which contains the information of the rednet search result.It gives the every detail present inside website in the form of json data.ExamplesBelow are some of the examples of URLs using which you can scrape:Example 1Example2Queries/ FeedbackIf you have some queries or feedback please contact us at followingTelegramEmail
Package: rednit.py
Tinder.pycomprehensive and feature rich wrapper for the Tinder APINote: This is an unofficial project, and I have nothing to do with Tinder nor their API. I take no responsibility for any potential damage, banned accounts or other troubles related to this project!The following example will demonstrate how easy it is to use this wrapper:client=TinderClient("X-Auth-Token")# Like recommended usersforrecommendationinclient.get_recommendations():recommendation.like()print(f"Liked user{recommendation.name}")# Send a message to all matchesformatchinclient.load_all_matches():match.send_message("Hello World")Featurescompletely wrapped Tinder modelscachingrate limitingintuitive api designAuthenticationTinder uses Basic Authentication with UUID strings. To get your token, first login to Tinder in your browser.
Then, open the network tab and filter for api.gotinder.com. Choose any GET or POST request and go to the Request Headers.
There, you'll find the X-Auth-Token header containing the auth token. Please note: you might need to perform some
actions first (for example liking a user) before you see any requests.DownloadN/ACredits@fbessezand@rttfor their initial reverse engineering
back in 2018 and 2014.@SnowJulifor their work on the docs and the linting workflow@MeerBienefor his support and general ideasand many more
Package: rednose
rednose is anosetestsplugin for adding colour (and readability) to nosetest console results.Installation:pip install rednoseor from the source:python setup.py installRednose officially supports Python 2.7, 3.4, and 3.5.Usage:nosetests --rednoseor:export NOSE_REDNOSE=1
nosetestsRednose by default uses auto-colouring, which will only use
colour if you’re running it on a terminal (i.e not piping it
to a file). To control colouring, use one of:nosetests --rednose --force-color
nosetests --no-color(you can also control this by setting the environment variable NOSE_REDNOSE_COLOR to ‘force’ or ‘no’)Rednose by default prints file paths relative to the working
directory. If you want the full path in the traceback then
use:nosetests --rednose --full-file-pathRednose by default prints error style formating for skipped tests,
to supress this use:nosetests --rednose --hide-skipsRednose supports printing the test results mid run as well as at
the end, to enable it use:nosetests --rednose --immediate
Package: redocparse
ReDocparseReDocparse is a small library that aims to make transforming large amounts of text easier.It introduces aredocparse.matcher.Matcherclass that matches a chunk of text via regex,
runs the matched text through an optional callback function,
then sends the matched text through each of its nested Matchers.In short, it's a more ergonomic way to use regex recursively.DiscordIncluded in this repository is src/discord, which is an application of ReDocparse aimed at creating Python dataclasses from the Discord API Documentation (specifically for use withDubiousDiscord).discord.parse_discord requiresInflectto run.
Package: red-october
||||Python Red October LibraryThis library allows you to interact with a remote Red October Instance using Python.Red October is a cryptographically-secure implementation of the two-person rule to
protect sensitive data. From a technical perspective, Red October is a software-based
encryption and decryption server. The server can be used to encrypt a payload in such
a way that no one individual can decrypt it. The encryption of the payload is
cryptographically tied to the credentials of the authorized users.Authorized persons can delegate their credentials to the server for a period of time.
The server can decrypt any previously-encrypted payloads as long as the appropriate number
of people have delegated their credentials to the server.This architecture allows Red October to act as a convenient decryption service. Other
systems, including CloudFlare’s build system, can use it for decryption and users can
delegate their credentials to the server via a simple web interface. All communication
with Red October is encrypted with TLS, ensuring that passwords are not sent in the clear.Read more on the CloudFlare blog.View the Red October source.InstallationInstall Python requirementspip install-r./requirementsSetupA pre-existing Red October server is required to use this library.UsageRead The API DocumentationKnown Issues / Road MapInstallation, setup, usage - in ReadMeCreditsImagesLasLabs:Icon.ContributorsDave Lasley <dave@laslabs.com>MaintainerThis module is maintained by LasLabs Inc.
Package: redomino.appytransforms
redomino.appytransformsIt registers a new portal transforms that let you dynamically generate odt or ods files for a given template.This product is based onhttp://appyframework.org/pod.htmlSince it aims to generate native LibreOffice/OpenOffice formats, it is not necessary running libre office in server mode.This plugin is meant for developers, it could be used for generating dynamic odt/ods files, write a custom PloneFormGen adapter, etc.UsageExample:>>> from zope.component import getUtility
>>> from Products.PortalTransforms.interfaces import IPortalTransformsTool
>>> file_contents = open('your odt file with variables').read()     # see redomino/appytransforms/tests/input.odt
>>> portal_transforms = getUtility(IPortalTransformsTool)
>>> converter = portal_transforms.convertTo(target_mimetype='application/vnd.oasis.opendocument.text.transformed',
>>>                                        orig=file_contents,
>>>                                        mimetype='application/vnd.oasis.opendocument.text',
>>>                                        mapper=dict(plone_version='4.3.2-sunny-day-beta'),
>>>                                       )
>>> transformed_odt_contents = converter.getData()appy.pod’s tips and limitationsTips and appy.pod’s limitations.Odt files:use the “Edit” -> “Changes” -> “Record” in order to display varsconditional text fields seems to be not supported (as far as I can see), use comments with do text if expr insteadlibreoffice does not support comments on single words (seehttp://ask.libreoffice.org/en/question/5256/comments-in-writer/), so it seems that you’ll have to the only way torepeating list items, it does not works as expectedOds files:don’t use the “Edit” -> “Changes” -> “Record” on ods files!repeat rows adding a comment on the first cell with “do row for person in persons” and put dynamic content putting into the cell value =”person[‘age’]”if you want to pass a single variable and displaying it into a single cell use the followind syntax into the cell value =”variable_name” (not as a comment)appy’s documentation is awful: if you are in trouble trying to get working ODT/ODS templates check out the tests dochttps://github.com/redomino/redomino.appytransforms/tree/master/redomino/appytransforms/testsTestsTest status:How to launch tests:$ ./bin/test -m redomino.appytransformsAuthorsDavide Moro <davide.moro@redomino.com>Changelog0.1 (2014-02-24)First release
[davidemoro]
Package: redomino.autodelete
Plone tool for autodeleting expired objectsredomino.autodelete is a product for Plone.
Once installed, you can set an expiration autodelete date for an object, and it will be automatically deleted after that date.
Before that time, you can always change your mind and disable the option.
Deletion is provided by an External Method added by default if PloneMaintenance is available.redomino.autodelete also provides a simple tool that allows the Manager to launch manually the delete task for expired objects.
Otherwise the deletion could be launched manually using the AutoDelete Tool.redomino.autodelete has been developed with Zope/Plone 3 technologies.For more info, questions and support, please see the home page of the project:http://www.redomino.com/it/labs/progetti/redomino-autodeleteINSTALLATIONredomino.autodelete installs automatically all dependencies.REQUIREMENTSTested and developed with:
- Plone 3.0.6 to 3.1.5.1
- PloneMaintenance 1.4.2 (not strictly required)CREDITSMain authors:
-Davide Moro (davide.moro@redomino.com)
-Fabrizio Reale (fabrizio.reale@redomino.com)