Saravanan666/pypi-org huggingface dataset:
Package: horace
HoraceFormat converter from PoetryLab JSON to POSTDATA semantic formatsFree software: Apache Software License 2.0Documentation:https://horace.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2020-09-01)First release on PyPI.
Package: horae.app
IntroductionThehorae.apppackage provides the Horae resource planning system as aGrok application. It pulls in all the requiredhorae.*packages and if available activates functionality for the
optional ones.DependenciesHoraehorae.authhorae.corehorae.propertieshorae.searchhorae.ticketingThird partygrokgrokui.admingrokcore.startupzope.i18n[compile]Changelog1.0a1 (2012-01-16)Initial release
Package: horae.attachments
IntroductionThehorae.attachmentspackage provides support for adding attachments
to tickets of the Horae resource planning system. This is done by using
the view extension mechanism provided byhorae.layoutto extend the ticket change
view provided byhorae.ticketingby a field to add multiple files. Additionally the display view and history
of a ticket is extended in the same way to have the added attachments
rendered as links.DependenciesHoraehorae.corehorae.layouthorae.propertieshorae.ticketingThird partygrokz3c.relationfieldChangelog1.0a1 (2012-01-16)Initial release
Package: horae.calendar
IntroductionThehorae.calendarpackage provides a generic calendar view having a
month, week and day perspective for the Horae resource planning system.UsageThe calendar is available on every context as a view namedcalendar.
The entries to be displayed by the calendar are taken from all the adapters
implementinghorae.calendar.interfaces.ICalendarEntriesand adapting
the context the view is currently viewed on. An example implementation
can be found in thehorae.planningpackage.DependenciesHoraehorae.corehorae.layoutThird partygrokfanstaticzope.fanstaticChangelog1.0a1 (2012-01-16)Initial release
Package: horae.dashboard
IntroductionThehorae.dashboardpackage provides user and group dashboards for the Horae
resource planning system. Every user and groups has its own dashboard which may
contain multiple widgets which may be individually positioned and resized.WidgetsThere are several dashboard widgets already implemented:Time trackingA widget to track time on ticketsUser ticketsA widget listing the tickets the current user is responsible forLatestA widget listing the latest changed objects of the current userNotificationsA widget listing the latest notifications for the current user. Only available if the
optionalhorae.notificationpackage is installed.Work time trackingA widget to track the work time of human resources. Only available if the optionalhorae.resourcespackage is installed.ReportsA widget displaying the results of a previously created report. Only available
if the optionalhorae.reportspackage
is installed.Creating widgetsCreating custom dashboard widgets is possible through the pluggable architecture of
the package. A widget consists of at least four parts:InterfaceThe interface defining the schema of the widget and extends the base schema provided
byhorae.dashboard.interfaces.IWidgetWidget factoryA named global utility implementinghorae.dashboard.interfaces.IWidgetFactoryWidgetA persistent widget extendinghorae.dashboard.dashboard.Widgetand implementing
the Interface mentioned aboveViewThe view namedindexrendering the widget in the dashboardA sample widget having one custom field which is later rendered on the widgets view
would be implemented as followed:import grok

from zope import schema
from zope.schema.fieldproperty import FieldProperty

from horae.dashboard import dashboard, interfaces

class ISampleWidget(interfaces.IWidget):

    content = schema.TextLine(
        title = u'Content',
        required = True
    )

class SampleWidgetFactory(grok.GlobalUtility):
    grok.name('sample')
    grok.implements(interfaces.IWidgetFactory)

    name = u'Sample'
    schema = ISampleWidget

    def __call__(self):
        return SampleWidget()

class SampleWidget(dashboard.Widget):
    grok.implements(ISampleWidget)

    title = u'Sample'
    content = FieldProperty(ISampleWidget['content'])

class SampleWidgetIndex(grok.View):
    grok.name('index')
    grok.require('horae.View')
    grok.context(ISampleWidget)

    def render(self):
        return self.context.contentDependenciesHoraehorae.authhorae.autocompletehorae.corehorae.datetimehorae.layouthorae.lifecyclehorae.propertieshorae.ticketinghorae.timeawareThird partygrokfanstaticzope.fanstaticChangelog1.0a1 (2012-01-16)Initial release
Package: horae.datetime
Introductionhorae.datetimeprovideszope.formlibinput widgets forDateandDatetimefields ofzope.schema. Both widgets use thedatepicker widget of jQuery UIto select the date. TheDatetimewidget additionally provides two
input fields to enter the hour and minute for the time. The hour and
minute fields are enhanced by theSpinbox jQuery plugin.UsageThe widgets may either be registered throughZCMLas new default input
widgets forDateandDatetimefields or by defining the widget ascustom_widgeton azope.formlibform. Registration as default widget has to be done either in anoverrides.zcmlor the registrations have to be bound to a specific browser layer.Registration using theoverrides.zcmlwould look like this:<configure xmlns='http://namespaces.zope.org/zope'>

  <view
      type="zope.publisher.interfaces.browser.IBrowserRequest"
      for="zope.schema.interfaces.IDatetime"
      provides="zope.app.form.interfaces.IInputWidget"
      factory="horae.datetime.widget.DatetimeWidget"
      permission="zope.Public"
      />

  <view
      type="zope.publisher.interfaces.browser.IBrowserRequest"
      for="zope.schema.interfaces.IDate"
      provides="zope.app.form.interfaces.IInputWidget"
      factory="horae.datetime.widget.DateWidget"
      permission="zope.Public"
      />

</configure>Dependenciesfanstaticzope.fanstaticjs.jqueryjs.jqueryuiChangelog1.0a1 (2012-01-16)Initial release
Package: horae.groupselect
Introductionhorae.groupselectprovides a groupedDropdownwidget forzope.formlibusing
the defaultoptgroupelements provided by HTML.UsageTo use a grouped dropdown widget the previously usedChoicefield
of the schema has to be replaced by aGroupedChoicefield provided
inhorae.groupedselect.field. AGroupedChoicefield takes the
exactly same parameters as the stockChoicefield but additionally
an instance of a groups provider (implementinghorae.groupedselect.interfaces.IGroups) has to be provided over the
parametergroups. The mentioned groups provider converts the
vocabulary of the field into a list of groups.Imagine field to select a country and you would like to group them by
region:from zope import interface, implements
from zope.schema import vocabulary

from horae.groupedselect import field, interfaces

class Country(object):
    def __init__(self, region, country):
        self.region = region
        self.country = country

class CountryGroups(object):
    implements(interfaces.IGroups)

    def groups(self, vocabulary):
        """
        Converts the given vocabulary into a list of groups:

            return (('Group 1', (term1, term2, term3)),
                    ('Group 2', (term6, term5, term6)),)
        """
        groups = {}
        for term in vocabulary:
            if not term.value.region in groups:
                groups[term.value.region] = ()
            groups[term.value.region] = groups[term.value.region] + \
                (term,)
        return groups.items()

class ICountrySelection(interface.Interface):

    country = field.GroupedChoice(
        title = u'Country',
        vocabulary = vocabulary.SimpleVocabulary((
            # ...
            vocabulary.SimpleTerm(
                Country(u'Europe', u'Switzerland'),
                'ch',
                u'Switzerland'
            ),
            vocabulary.SimpleTerm(
                Country(u'Europe', u'Germany'),
                'de',
                u'Germany'
            ),
            vocabulary.SimpleTerm(
                Country(u'Europe', u'Austria'),
                'at',
                u'Austria'
            ),
            vocabulary.SimpleTerm(
                Country(u'Europe', u'France'),
                'fr',
                u'France'
            ),
            # ...
            vocabulary.SimpleTerm(
                Country(u'North America', u'USA'),
                'us',
                u'USA'
            ),
            vocabulary.SimpleTerm(
                Country(u'Europe', u'Canada'),
                'ca',
                u'Canada'
            ),
            # ...
        )),
        groups = CountryGroups()
    )Dependencieszope.schemazope.formlibChangelog1.0a1 (2012-01-16)Initial release
Package: horae.lifecycle
Introductionhorae.lifecyclehandles the lifecycle of objects for the Horae resource
planning system. It stores thecreator,creation_date,modifierandmodification_dateof objects implementinghorae.lifecycle.interfaces.ILifecycleAware. Additionally it provides
a viewlet displaying the collected information in context and a storage
for latest objects of a user which tracks what objects were changed by a
given user.UsageThe easiest way to activate the functionality provided byhorae.lifecycleis to subclass from the provided mix in classhorae.lifecycle.lifecycle.LifecycleAwareMixin:import grok

from horae.lifecycle import lifecycle

class SampleContent(grok.Model, lifecycle.LifecycleAwareMixin):
    """ Sample content aware of his lifecycle
    """LatestThe latest storage is provided as an adapter implementinghorae.lifecycle.interfaces.ILatestand adapting a principal. There is a convenience adapter adapting therequestavailable which returns the storage for the current user:from horae.lifecycle import interfaces

class SampleView(grok.View):

    def latest(self):
        latest = interfaces.ILatest(self.request)
        return latest.objects()DependenciesHoraehorae.authhorae.corehorae.layouthorae.timeawareThird partygrokzope.principalannotationChangelog1.0a1 (2012-01-16)Initial release
Package: horae.notification
Introductionhorae.notificationprovides persistent and email notifications
for the Horae resource planning system.Persistent notificationsPersistent notifications are displayed by a viewlet and a corresponding
view. They are issued by adding new notifications (implementinghorae.notification.interfaces.INotificationto the notifications
adapter registered for the interfacehorae.notification.interfaces.INotifications.
Examples may be found inhorae.notification.subscriptionandhorae.planning.notification.Email notificationsEmail notifications are handled by using thehorae.subscriptionpackage and  are sent
out to all subscribers of a ticket after it has changed.DependenciesHoraehorae.authhorae.corehorae.layouthorae.subscriptionhorae.ticketingThird partypyandoczope.sendmailSystemhorae.notificationrequiresPandoca universal document converter to convert from HTML to reStructeredText
to send the email notifications. Installation instructions for Pandoc may be
found online athttp://johnmacfarlane.net/pandoc/installing.html.Changelog1.0a1 (2012-01-16)Initial release
Package: horae.planning
Introductionhorae.planningprovides resource planning functionality for the Horae
resource planning system including the following functionality:Prioritization of projects using drag and dropPrioritization of tickets in a project and specific for resources using
drag and dropCalculation of forecasts based on the planned resources and priorities
for all the open ticketsPossibility to store the current forecast as a planning entryView to view the tickets and the corresponding forecast, effective work
time and stored planning entries on a time lineIssues notifications usinghorae.notificationif a deadline will not
be reached after forecast recalculationProvides calendar entries forhorae.calendarbased on the stored planning
entriesDependenciesHoraehorae.authhorae.autocompletehorae.calendarhorae.corehorae.js.jqplothorae.layouthorae.propertieshorae.resourceshorae.searchhorae.ticketinghorae.timeawareThird partygrokfanstaticzope.fanstaticChangelog1.0a1 (2012-01-16)Initial release
Package: horae.properties
Introductionhorae.propertiesprovides the dynamic property infrastructure used by
the client, project, milestone and ticket content objects of thehorae.ticketing.UsageThe package builds up on three main classes:PropertiesContainer for persistent propertiesPropertyA property providing one or more fieldsPropertiedAn object based on the fields provided by the properties which are
defined by the corresponding property containersObjects using the property architecture have to subclass thehorae.properties.propertied.PropertiedMixinmix in class and their
add, edit and display forms have to subclass the corresponding base classesPropertiedAddForm,PropertiedEditFormandPropertiedDisplayFormdefined inhorae.properties.views. The properties for a propertied
object are collected from all named adapters implementinghorae.properties.interfaces.IPropertiesand adapting the object.
Sample implementations may be found in thehorae.ticketingpackage.There are five property containers implemented byhorae.propertieswhich
there are:Global propertiesProperties available for all propertied objectsClient propertiesProperties available for clientsProject propertiesProperties available for projectsMilestone propertiesProperties available for milestonesTicket propertiesProperties available for ticketsProperties may be created or customized persistently using the GUI
provided byhorae.properties. Another way to define properties
is by defining them as default properties which is done by registering
a named global utility implementinghorae.properties.interfaces.IDefaultProperty.
Examples of such default properties may be found in thehorae.ticketingpackage.Property typesThe package provides the followingPropertyimplementations defined inhorae.properties.properties:BoolPropertyA boolean propertyTextLinePropertyA textline propertyTextPropertyA text propertyRichTextPropertyA rich text propertyChoicePropertyA choice propertyMultipleChoicePropertyA multiple choice propertyWeightedChoicePropertyA choice property having weighted optionsFloatPropertyA float propertyPricePropertyA price propertyUserPropertyA user propertyUserRolePropertyA user role propertyGroupPropertyA group propertyGroupRolePropertyA group role propertyDateTimePropertyA date time propertyDateTimeRangePropertyA date time range propertyHistoryAPropertiedobject stores changes in a list ofPropertyChangeobjects
to preserve a changelog of the lifecycle. A view of the whole history
may be provided by sub-classing thehorae.properties.views.Historybase
class.DependenciesHoraehorae.authhorae.autocompletehorae.cachehorae.corehorae.layouthorae.lifecyclehorae.timeawareThird partygrokz3c.relationfieldChangelog1.0a1 (2012-01-16)Initial release
Package: horae.reports
IntroductionThehorae.reportspackage makes it possible to store a search
as a report which may be publicly available for all users or may be
shared with specific groups or users using the sharing functionality
provided byhorae.auth.DependenciesHoraehorae.authhorae.corehorae.layouthorae.lifecyclehorae.propertieshorae.searchhorae.ticketingThird partygrokChangelog1.0a1 (2012-01-16)Initial release
Package: horae.resources
Introductionhorae.resourcesprovides resource management functionality for the
Horae resource planning system which includes:Global cost unitsGlobal resourcesHuman resourcesOne time resourcesHourly resourcesDefining the planned work time for human resourcesDefining absences for human resourcesTracking of effective work time for human resourcesPlanning human resources and the corresponding cost unit for ticketsAssociation of time booked on a ticket with a planned resource
(human resource and cost unit)Enter one time and hourly expenses on ticketsCanceling previously entered expenses on ticketsCost unitsCost units are simple definitions of types of work that may be done and
consist of a name and an hourly rate.ResourcesFor every resource one may define what users or groups are allowed to
enter expenses of this resource. Following the three types of resources
are shortly explained.Human resourcesHuman resources consist of a name, a defined set of cost units and are
linked with a user of the system. Additionally every human resource
holds its planned work time, absences and effective work time.One time resourcesOne time resources are categories for one time expenses booked on tickets.
They only consist of a name. In an IT-companySoftware,HardwareandLicencemay be useful one time resources.Hourly resourcesHourly resources are the possibly least used resources. They consist of a
name and an hourly rate. They may later be entered on a ticket in combination
with a time range as an hourly expense. A possible use case for hourly resources
may arise for example in a manufacturing company where a used machine has an
hourly cost which one would like to have entered on a ticket.DependenciesHoraehorae.authhorae.corehorae.groupselecthorae.layouthorae.propertieshorae.ticketinghorae.timeawareThird partygrokz3c.relationfieldhurry.queryChangelog1.0a1 (2012-01-16)Initial release
Package: horae.sphinx.grok
Introductionhorae.sphinx.grokis an extension for theSphinxdocumentation generator. It provides two new autodoc directivesautogrokandautogrokfunction. By using those directives instead of the stockautoclassandautofunctionones additional grok specific information is given about
the class or function.If theautogrokdirective is as an example used on the following class definition:class ExampleAdapter(grok.Adapter):
    """
    An adapter demonstrating the autogrok directive
    """
    grok.context(IAdaptee)
    grok.implements(ISomeFunctionality)
    grok.name('example')The reStructuredText output of the docstring would look like this:An adapter demonstrating the autogrok directive

:context:
    :class:`IAdaptee`
:implements:
    :class:`ISomeFunctionality`
:name:
    exampleTheautogrokfunctionis doing the same for functions:@grok.adapter(IAdaptee, name="example")
@grok.implementer(ISomeFunctionality)
def example_adapter_factory(context):
    """
    An adapter factory demonstrating the autogrokfunction directive
    """
    return ExampleAdapter(context)Which would result in:An adapter factory demonstrating the autogrokfunction directive

:context:
    :class:`IAdaptee`
:implements:
    :class:`ISomeFunctionality`
:name:
    exampleChangelog1.0a1 (2012-01-16)Initial release
Package: horae.subscription
Introductionhorae.subscriptionprovides generic subscription functionality for the
Horae resource planning system.UsageObjects marked with thehorae.subscription.interfaces.ISubscribeableinterfaces receive the functionality of being subscribed to. Which means
a viewlet is displayed rendering all subscribers and a button to subscribe
and unsubscribe if an adapter implementinghorae.subscription.interfaces.ISubscriberand adapting the request is available.The subscribers of anhorae.subscription.interfaces.ISubscribeablemay be
notified by using thehorae.subscription.interfaces.ISubscriptionadapter.
First some basic implementations are required:import grok

from horae.subscription import interfaces

class Subscriber(object):
    grok.implements(interfaces.ISubscriber)

    def __init__(self, id, name, url=None):
        self.id = id
        self.name = name
        self.url = url

    def notify(self, message, subject):
        """ Sends the message to the subscriber
        """
        print self.name + ': (' + subject + ') ' + subject

    def available(self, context):
        """ Whether this subscriber is currently available or not
        """
        return True

class Message(object):
    grok.implements(interfaces.IMessage)

    def __init__(self, subject, message):
        self._subject = subject
        self._message = message

    def subject(self):
        """ Returns the subject of the notification to be sent
        """
        return self._subject

    def message(self, html=False):
        """ Returns the notification message to be sent
        """
        return self._message

class Subscribeable(grok.Model):
    grok.implements(interfaces.ISubscribeable)With those implementations in place some subscriptions may be made and
a message may be sent to them.First we create a subscribeable object:>>> subscribeable = Subscribeable()Now we create two subscribers and subscribe them to the subscribeable:>>> subscriber1 = Subscriber('jsmith', 'John Smith')
>>> subscriber2 = Subscriber('jdoe', 'John Doe')
>>> subscription = interfaces.ISubscription(subscribeable)
>>> subscription.subscribe(subscriber1)
>>> subscription.subscribe(subscriber2)And send out a message:>>> message = Message('Test subject', 'Test message')
>>> sent, failed = subscription.notify(message)
John Smith: (Test subject) Test message
John Doe: (Test subject) Test message
>>> sent
2
>>> failed
0Unsubscription is also done using the subscription adapter:>>> subscription.unsubscribe(subscriber2.id)
>>> sent, failed = subscription.notify(message)
John Smith: (Test subject) Test message
>>> sent
1
>>> failed
0DependenciesHoraehorae.corehorae.layouthorae.ticketingThird partygrokChangelog1.0a1 (2012-01-16)Initial release
Package: horae.ticketing
IntroductionThehorae.ticketingpackage implements the different models and their
hierarchy for the Horae resource planning system which there are:ClientProjectMilestoneTicketWhere clients hold projects and projects hold milestones and tickets. Tickets
may optionally be grouped into milestones. All the aforementioned models are using
the property architecture provided by thehorae.propertiespackage and thus implementhorae.properties.interfaces.IPropertied. The following default properties
are registered for the different containers:Global propertiesName (horae.properties.properties.TextLineProperty)Description (horae.properties.properties.RichTextProperty)Tags (horae.properties.properties.KeywordProperty)Project propertiesStart/due date (horae.properties.properties.DateTimeRangeProperty)Milestone propertiesStart/due date (horae.properties.properties.DateTimeRangeProperty)Ticket propertiesEstimated hours (horae.properties.properties.FloatProperty)Start/due date (horae.properties.properties.DateTimeRangeProperty)Responsible (horae.properties.properties.UserRoleProperty)Comment title (horae.properties.properties.TextLineProperty)Comment (horae.properties.properties.RichTextProperty)Milestone (horae.properties.properties.MilestoneProperty)Hidden fields (horae.properties.properties.FieldsProperty)Dependencies (horae.ticketing.properties.TicketReferenceProperty)DependenciesHoraehorae.authhorae.cachehorae.corehorae.layouthorae.lifecyclehorae.propertieshorae.searchhorae.timeawareThird partygrokz3c.relationfieldhurry.queryChangelog1.0a1 (2012-01-16)Initial release
Package: horae.workflow
IntroductionThehorae.workflowpackage provides dynamic workflows for the models
defined by thehorae.ticketingpackage using the workflow implementation provided by thehurry.workflowpackage.DependenciesHoraehorae.authhorae.autocompletehorae.cachehorae.corehorae.layouthorae.propertieshorae.searchhorae.ticketingThird partygrokhurry.workflowChangelog1.0a1 (2012-01-16)Initial release
Package: horasCLI
HorasCLISimple CLI program to create a project hour schedule in markdown.InstallPip methodhorasCLIOpen your terminal and type:pip install horasCLIClone repository methodClone thisrepositoryGo to the folder through terminal or open the terminal there and typepip install -e .UseTo get help about use type:horasCLI -horhorasCLI --helpTODOTest in Linux and MacOS